DelegatingMVCGroup (Griffon 2.13.0)

java.lang.Object
- org.codehaus.griffon.runtime.core.mvc.DelegatingMVCGroup

All Implemented Interfaces:

MVCGroup, MVCHandler

Direct Known Subclasses:

AbstractTypedMVCGroup
```
public abstract class DelegatingMVCGroup
extends java.lang.Object
implements MVCGroup
```
Since:

2.11.0

Author:

Andres Almiray

Constructor Summary

Constructors
Constructor and Description

DelegatingMVCGroup(MVCGroup delegate)

Constructors
Constructor and Description
`DelegatingMVCGroup(MVCGroup delegate)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<MVC extends TypedMVCGroup> java.util.List<? extends GriffonMvcArtifact>`	`createMVC(java.lang.Class<? extends MVC> mvcType)` Instantiates an MVC group of the specified type returning only the MVC parts.
`<MVC extends TypedMVCGroup> java.util.List<? extends GriffonMvcArtifact>`	`createMVC(java.lang.Class<? extends MVC> mvcType, java.util.Map<java.lang.String,java.lang.Object> args)` Instantiates an MVC group of the specified type with additional variables.
`<MVC extends TypedMVCGroup> java.util.List<? extends GriffonMvcArtifact>`	`createMVC(java.lang.Class<? extends MVC> mvcType, java.lang.String mvcId)` Instantiates an MVC group of the specified type with a particular name.
`<MVC extends TypedMVCGroup> java.util.List<? extends GriffonMvcArtifact>`	`createMVC(java.lang.Class<? extends MVC> mvcType, java.lang.String mvcId, java.util.Map<java.lang.String,java.lang.Object> args)` Instantiates an MVC group of the specified type with a particular name.
`<MVC extends TypedMVCGroup> java.util.List<? extends GriffonMvcArtifact>`	`createMVC(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.Class<? extends MVC> mvcType)` Instantiates an MVC group of the specified type with additional variables.
`<MVC extends TypedMVCGroup> java.util.List<? extends GriffonMvcArtifact>`	`createMVC(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.Class<? extends MVC> mvcType, java.lang.String mvcId)` Instantiates an MVC group of the specified type with a particular name.
`java.util.List<? extends GriffonMvcArtifact>`	`createMVC(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.String mvcType)` Instantiates an MVC group of the specified type with additional variables.
`java.util.List<? extends GriffonMvcArtifact>`	`createMVC(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.String mvcType, java.lang.String mvcId)` Instantiates an MVC group of the specified type with a particular name.
`java.util.List<? extends GriffonMvcArtifact>`	`createMVC(java.lang.String mvcType)` Instantiates an MVC group of the specified type returning only the MVC parts.
`java.util.List<? extends GriffonMvcArtifact>`	`createMVC(java.lang.String mvcType, java.util.Map<java.lang.String,java.lang.Object> args)` Instantiates an MVC group of the specified type with additional variables.
`java.util.List<? extends GriffonMvcArtifact>`	`createMVC(java.lang.String mvcType, java.lang.String mvcId)` Instantiates an MVC group of the specified type with a particular name.
`java.util.List<? extends GriffonMvcArtifact>`	`createMVC(java.lang.String mvcType, java.lang.String mvcId, java.util.Map<java.lang.String,java.lang.Object> args)` Instantiates an MVC group of the specified type with a particular name.
`<MVC extends TypedMVCGroup> MVC`	`createMVCGroup(java.lang.Class<? extends MVC> mvcType)` Instantiates an MVC group of the specified type.
`<MVC extends TypedMVCGroup> MVC`	`createMVCGroup(java.lang.Class<? extends MVC> mvcType, java.util.Map<java.lang.String,java.lang.Object> args)` Instantiates an MVC group of the specified type with additional variables.
`<MVC extends TypedMVCGroup> MVC`	`createMVCGroup(java.lang.Class<? extends MVC> mvcType, java.lang.String mvcId)` Instantiates an MVC group of the specified type with a particular name.
`<MVC extends TypedMVCGroup> MVC`	`createMVCGroup(java.lang.Class<? extends MVC> mvcType, java.lang.String mvcId, java.util.Map<java.lang.String,java.lang.Object> args)` Instantiates an MVC group of the specified type with a particular name.
`<MVC extends TypedMVCGroup> MVC`	`createMVCGroup(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.Class<? extends MVC> mvcType)` Instantiates an MVC group of the specified type with additional variables.
`<MVC extends TypedMVCGroup> MVC`	`createMVCGroup(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.Class<? extends MVC> mvcType, java.lang.String mvcId)` Instantiates an MVC group of the specified type with a particular name.
`MVCGroup`	`createMVCGroup(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.String mvcType)` Instantiates an MVC group of the specified type with additional variables.
`MVCGroup`	`createMVCGroup(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.String mvcType, java.lang.String mvcId)` Instantiates an MVC group of the specified type with a particular name.
`MVCGroup`	`createMVCGroup(java.lang.String mvcType)` Instantiates an MVC group of the specified type.
`MVCGroup`	`createMVCGroup(java.lang.String mvcType, java.util.Map<java.lang.String,java.lang.Object> args)` Instantiates an MVC group of the specified type with additional variables.
`MVCGroup`	`createMVCGroup(java.lang.String mvcType, java.lang.String mvcId)` Instantiates an MVC group of the specified type with a particular name.
`MVCGroup`	`createMVCGroup(java.lang.String mvcType, java.lang.String mvcId, java.util.Map<java.lang.String,java.lang.Object> args)` Instantiates an MVC group of the specified type with a particular name.
`MVCGroup`	`delegate()`
`void`	`destroy()` Destroys the current group.
`void`	`destroyMVCGroup(java.lang.String mvcId)` Destroys an MVC group identified by a particular name.
`java.util.Map<java.lang.String,MVCGroup>`	`getChildrenGroups()` Returns an immutable view of all children groups for which this group is a parent
`MVCGroupConfiguration`	`getConfiguration()` Returns the configuration of this group.
`Context`	`getContext()` Returns the context belonging to this group.
`GriffonController`	`getController()` Returns the Controller portion of this group.
`java.lang.Object`	`getMember(java.lang.String name)` Returns the specified member type.
`java.util.Map<java.lang.String,java.lang.Object>`	`getMembers()` Returns a read-only view of all instance members.
`GriffonModel`	`getModel()` Returns the Model portion of this group.
`java.lang.String`	`getMvcId()` Returns the id of the group.
`java.lang.String`	`getMvcType()` Returns the type of this group as set in the application's configuration.
`MVCGroup`	`getParentGroup()` Returns the parent `MVCGroup` of this group.
`GriffonView`	`getView()` Returns the View portion of this group.
`boolean`	`isAlive()` Returns whether this group has been destroyed or not.
`void`	`notifyMVCGroupDestroyed(java.lang.String mvcId)` Notifies the group when another MVC group has been destroyed, potentially a child group.
`<MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> void`	`withMVC(java.lang.Class<? extends MVC> mvcType, java.util.Map<java.lang.String,java.lang.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(java.lang.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(java.lang.Class<? extends MVC> mvcType, java.lang.String mvcId, java.util.Map<java.lang.String,java.lang.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(java.lang.Class<? extends MVC> mvcType, java.lang.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(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.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(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.Class<? extends MVC> mvcType, java.lang.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(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.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(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.String mvcType, java.lang.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(java.lang.String mvcType, java.util.Map<java.lang.String,java.lang.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(java.lang.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(java.lang.String mvcType, java.lang.String mvcId, java.util.Map<java.lang.String,java.lang.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(java.lang.String mvcType, java.lang.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(java.lang.Class<? extends MVC> mvcType, java.util.Map<java.lang.String,java.lang.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(java.lang.Class<? extends MVC> mvcType, java.lang.String mvcId, java.util.Map<java.lang.String,java.lang.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(java.lang.Class<? extends MVC> mvcType, java.lang.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(java.lang.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(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.Class<? extends MVC> mvcType, java.lang.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(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.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(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.String mvcType, MVCGroupFunction handler)` Instantiates an MVC group of the specified type then destroys it after it has been handled.
`void`	`withMVCGroup(java.util.Map<java.lang.String,java.lang.Object> args, java.lang.String mvcType, java.lang.String mvcId, MVCGroupFunction handler)` Instantiates an MVC group of the specified type then destroys it after it has been handled.
`void`	`withMVCGroup(java.lang.String mvcType, java.util.Map<java.lang.String,java.lang.Object> args, MVCGroupFunction handler)` Instantiates an MVC group of the specified type then destroys it after it has been handled.
`void`	`withMVCGroup(java.lang.String mvcType, MVCGroupFunction handler)` Instantiates an MVC group of the specified type then destroys it after it has been handled.
`void`	`withMVCGroup(java.lang.String mvcType, java.lang.String mvcId, java.util.Map<java.lang.String,java.lang.Object> args, MVCGroupFunction handler)` Instantiates an MVC group of the specified type then destroys it after it has been handled.
`void`	`withMVCGroup(java.lang.String mvcType, java.lang.String mvcId, MVCGroupFunction handler)` Instantiates an MVC group of the specified type then destroys it after it has been handled.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DelegatingMVCGroup
```
public DelegatingMVCGroup(@Nonnull
                          MVCGroup delegate)
```
- Method Detail
  - delegate
```
@Nonnull
public MVCGroup delegate()
```
  - getConfiguration
```
@Nonnull
public MVCGroupConfiguration getConfiguration()
```
    Description copied from interface: MVCGroup
    
    Returns the configuration of this group.
    
    Specified by:
    
    getConfiguration in interface MVCGroup
    
    Returns:
    
    the configuration used to instantiate this group.
  - getMvcType
```
@Nonnull
public java.lang.String getMvcType()
```
    Description copied from interface: MVCGroup
    
    Returns the type of this group as set in the application's configuration.
    
    Specified by:
    
    getMvcType in interface MVCGroup
    
    Returns:
    
    the type of the group
  - getMvcId
```
@Nonnull
public java.lang.String getMvcId()
```
    Description copied from interface: MVCGroup
    
    Returns the id of the group. Ids are used to uniquely identify a group instance.
    
    Specified by:
    
    getMvcId in interface MVCGroup
    
    Returns:
    
    the id of this group.
  - getModel
```
@Nullable
public GriffonModel getModel()
```
    Description copied from interface: MVCGroup
    
    Returns the Model portion of this group.
    
    Specified by:
    
    getModel in interface MVCGroup
    
    Returns:
    
    a GriffonModel instance if the group has a model member, null otherwise
  - getView
```
@Nullable
public GriffonView getView()
```
    Description copied from interface: MVCGroup
    
    Returns the View portion of this group.
    
    Specified by:
    
    getView in interface MVCGroup
    
    Returns:
    
    a GriffonView instance if the group has a view member, null otherwise
  - getController
```
@Nullable
public GriffonController getController()
```
    Description copied from interface: MVCGroup
    
    Returns the Controller portion of this group.
    
    Specified by:
    
    getController in interface MVCGroup
    
    Returns:
    
    a GriffonController instance if the group has a controller member, null otherwise
  - getMember
```
@Nullable
public java.lang.Object getMember(@Nonnull
                                            java.lang.String name)
```
    Description copied from interface: MVCGroup
    
    Returns the specified member type.
    
    Specified by:
    
    getMember in interface MVCGroup
    
    Parameters:
    
    name - the type of member to retrieve
    
    Returns:
    
    the selected MVC member if a match is found, null otherwise
  - getMembers
```
@Nonnull
public java.util.Map<java.lang.String,java.lang.Object> getMembers()
```
    Description copied from interface: MVCGroup
    
    Returns a read-only view of all instance members.
    
    Specified by:
    
    getMembers in interface MVCGroup
    
    Returns:
    
    an unmodifiable Map view of all members.
  - destroy
```
public void destroy()
```
    Description copied from interface: MVCGroup
    
    Destroys the current group. Should only be called once.
    
    Specified by:
    
    destroy in interface MVCGroup
  - isAlive
```
public boolean isAlive()
```
    Description copied from interface: MVCGroup
    
    Returns whether this group has been destroyed or not.
    
    Specified by:
    
    isAlive in interface MVCGroup
    
    Returns:
    
    true if the group has not been destroyed yet, false otherwise
  - getContext
```
@Nonnull
public Context getContext()
```
    Description copied from interface: MVCGroup
    
    Returns the context belonging to this group.
    
    Specified by:
    
    getContext in interface MVCGroup
  - getParentGroup
```
@Nullable
public MVCGroup getParentGroup()
```
    Description copied from interface: MVCGroup
    
    Returns the parent MVCGroup of this group.
    The parent may be null if this is a top level MVC group.
    
    Specified by:
    
    getParentGroup in interface MVCGroup
  - getChildrenGroups
```
@Nonnull
public java.util.Map<java.lang.String,MVCGroup> getChildrenGroups()
```
    Description copied from interface: MVCGroup
    
    Returns an immutable view of all children groups for which this group is a parent
    
    Specified by:
    
    getChildrenGroups in interface MVCGroup
    
    Returns:
    
    an immutable view of children groups, keyed by mvcId.
  - notifyMVCGroupDestroyed
```
public void notifyMVCGroupDestroyed(@Nonnull
                                    java.lang.String mvcId)
```
    Description copied from interface: MVCGroup
    
    Notifies the group when another MVC group has been destroyed, potentially a child group.
    
    Specified by:
    
    notifyMVCGroupDestroyed in interface MVCGroup
    
    Parameters:
    
    mvcId - the id of the group that has been destroyed
  - createMVCGroup
```
@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        java.lang.String mvcType)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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)
 
```
    Specified by:
    
    createMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    Returns:
    
    an MVCGroup instance of the desired type
  - createMVCGroup
```
@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        java.lang.String mvcType,
                                        @Nonnull
                                        java.lang.String mvcId)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with a particular name.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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.
    Specified by:
    
    createMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    Returns:
    
    an MVCGroup instance of the desired type
  - createMVCGroup
```
@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        java.util.Map<java.lang.String,java.lang.Object> args,
                                        @Nonnull
                                        java.lang.String mvcType)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with additional variables.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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
 
```
    Specified by:
    
    createMVCGroup in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    Returns:
    
    an MVCGroup instance of the desired type
  - createMVCGroup
```
@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        java.lang.String mvcType,
                                        @Nonnull
                                        java.util.Map<java.lang.String,java.lang.Object> args)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with additional variables.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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
 
```
    Specified by:
    
    createMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    Returns:
    
    an MVCGroup instance of the desired type
  - createMVCGroup
```
@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        java.util.Map<java.lang.String,java.lang.Object> args,
                                        @Nonnull
                                        java.lang.String mvcType,
                                        @Nonnull
                                        java.lang.String mvcId)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with a particular name.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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.
    Specified by:
    
    createMVCGroup in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    Returns:
    
    an MVCGroup instance of the desired type
  - createMVCGroup
```
@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        java.lang.String mvcType,
                                        @Nonnull
                                        java.lang.String mvcId,
                                        @Nonnull
                                        java.util.Map<java.lang.String,java.lang.Object> args)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with a particular name.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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.
    Specified by:
    
    createMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    Returns:
    
    an MVCGroup instance of the desired type
  - createMVCGroup
```
@Nonnull
public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull
                                                               java.lang.Class<? extends MVC> mvcType)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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)
 
```
    Specified by:
    
    createMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    Returns:
    
    an MVCGroup instance of the desired type
  - createMVCGroup
```
@Nonnull
public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull
                                                               java.lang.Class<? extends MVC> mvcType,
                                                               @Nonnull
                                                               java.lang.String mvcId)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with a particular name.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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.
    Specified by:
    
    createMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    Returns:
    
    an MVCGroup instance of the desired type
  - createMVCGroup
```
@Nonnull
public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull
                                                               java.util.Map<java.lang.String,java.lang.Object> args,
                                                               @Nonnull
                                                               java.lang.Class<? extends MVC> mvcType)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with additional variables.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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
 
```
    Specified by:
    
    createMVCGroup in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    Returns:
    
    an MVCGroup instance of the desired type
  - createMVCGroup
```
@Nonnull
public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull
                                                               java.lang.Class<? extends MVC> mvcType,
                                                               @Nonnull
                                                               java.util.Map<java.lang.String,java.lang.Object> args)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with additional variables.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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
 
```
    Specified by:
    
    createMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    Returns:
    
    an MVCGroup instance of the desired type
  - createMVCGroup
```
@Nonnull
public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull
                                                               java.util.Map<java.lang.String,java.lang.Object> args,
                                                               @Nonnull
                                                               java.lang.Class<? extends MVC> mvcType,
                                                               @Nonnull
                                                               java.lang.String mvcId)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with a particular name.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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.
    Specified by:
    
    createMVCGroup in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    Returns:
    
    an MVCGroup instance of the desired type
  - createMVCGroup
```
@Nonnull
public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull
                                                               java.lang.Class<? extends MVC> mvcType,
                                                               @Nonnull
                                                               java.lang.String mvcId,
                                                               @Nonnull
                                                               java.util.Map<java.lang.String,java.lang.Object> args)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with a particular name.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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.
    Specified by:
    
    createMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    Returns:
    
    an MVCGroup instance of the desired type
  - createMVC
```
@Nonnull
public java.util.List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                       java.lang.String mvcType)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type returning only the MVC parts.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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)
 
```
    Specified by:
    
    createMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    Returns:
    
    a List with the canonical MVC members of the group
  - createMVC
```
@Nonnull
public java.util.List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                       java.util.Map<java.lang.String,java.lang.Object> args,
                                                                       @Nonnull
                                                                       java.lang.String mvcType)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with additional variables.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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
 
```
    Specified by:
    
    createMVC in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    Returns:
    
    a List with the canonical MVC members of the group
  - createMVC
```
@Nonnull
public java.util.List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                       java.lang.String mvcType,
                                                                       @Nonnull
                                                                       java.util.Map<java.lang.String,java.lang.Object> args)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with additional variables.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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
 
```
    Specified by:
    
    createMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    Returns:
    
    a List with the canonical MVC members of the group
  - createMVC
```
@Nonnull
public java.util.List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                       java.lang.String mvcType,
                                                                       @Nonnull
                                                                       java.lang.String mvcId)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with a particular name.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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.
    Specified by:
    
    createMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    Returns:
    
    a List with the canonical MVC members of the group
  - createMVC
```
@Nonnull
public java.util.List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                       java.util.Map<java.lang.String,java.lang.Object> args,
                                                                       @Nonnull
                                                                       java.lang.String mvcType,
                                                                       @Nonnull
                                                                       java.lang.String mvcId)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with a particular name.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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.
    Specified by:
    
    createMVC in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    Returns:
    
    a List with the canonical MVC members of the group
  - createMVC
```
@Nonnull
public java.util.List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                       java.lang.String mvcType,
                                                                       @Nonnull
                                                                       java.lang.String mvcId,
                                                                       @Nonnull
                                                                       java.util.Map<java.lang.String,java.lang.Object> args)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with a particular name.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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.
    Specified by:
    
    createMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    Returns:
    
    a List with the canonical MVC members of the group
  - createMVC
```
@Nonnull
public <MVC extends TypedMVCGroup> java.util.List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                                                   java.lang.Class<? extends MVC> mvcType)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type returning only the MVC parts.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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)
 
```
    Specified by:
    
    createMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    Returns:
    
    a List with the canonical MVC members of the group
  - createMVC
```
@Nonnull
public <MVC extends TypedMVCGroup> java.util.List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                                                   java.util.Map<java.lang.String,java.lang.Object> args,
                                                                                                   @Nonnull
                                                                                                   java.lang.Class<? extends MVC> mvcType)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with additional variables.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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
 
```
    Specified by:
    
    createMVC in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    Returns:
    
    a List with the canonical MVC members of the group
  - createMVC
```
@Nonnull
public <MVC extends TypedMVCGroup> java.util.List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                                                   java.lang.Class<? extends MVC> mvcType,
                                                                                                   @Nonnull
                                                                                                   java.util.Map<java.lang.String,java.lang.Object> args)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with additional variables.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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
 
```
    Specified by:
    
    createMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    Returns:
    
    a List with the canonical MVC members of the group
  - createMVC
```
@Nonnull
public <MVC extends TypedMVCGroup> java.util.List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                                                   java.lang.Class<? extends MVC> mvcType,
                                                                                                   @Nonnull
                                                                                                   java.lang.String mvcId)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with a particular name.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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.
    Specified by:
    
    createMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    Returns:
    
    a List with the canonical MVC members of the group
  - createMVC
```
@Nonnull
public <MVC extends TypedMVCGroup> java.util.List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                                                   java.util.Map<java.lang.String,java.lang.Object> args,
                                                                                                   @Nonnull
                                                                                                   java.lang.Class<? extends MVC> mvcType,
                                                                                                   @Nonnull
                                                                                                   java.lang.String mvcId)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with a particular name.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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.
    Specified by:
    
    createMVC in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    Returns:
    
    a List with the canonical MVC members of the group
  - createMVC
```
@Nonnull
public <MVC extends TypedMVCGroup> java.util.List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                                                   java.lang.Class<? extends MVC> mvcType,
                                                                                                   @Nonnull
                                                                                                   java.lang.String mvcId,
                                                                                                   @Nonnull
                                                                                                   java.util.Map<java.lang.String,java.lang.Object> args)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type with a particular name.
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    For example, with the following entry available in 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.
    Specified by:
    
    createMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    Returns:
    
    a List with the canonical MVC members of the group
  - destroyMVCGroup
```
public void destroyMVCGroup(@Nonnull
                            java.lang.String mvcId)
```
    Description copied from interface: MVCHandler
    
    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.
    
    Specified by:
    
    destroyMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcId - the name of the group to destroy and dispose.
  - withMVC
```
public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               java.lang.String mvcType,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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();
     }
 });
 
```
    Specified by:
    
    withMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVC
```
public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               java.lang.String mvcType,
                                                                                               @Nonnull
                                                                                               java.lang.String mvcId,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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.
    Specified by:
    
    withMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVC
```
public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               java.lang.String mvcType,
                                                                                               @Nonnull
                                                                                               java.lang.String mvcId,
                                                                                               @Nonnull
                                                                                               java.util.Map<java.lang.String,java.lang.Object> args,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVC
```
public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               java.util.Map<java.lang.String,java.lang.Object> args,
                                                                                               @Nonnull
                                                                                               java.lang.String mvcType,
                                                                                               @Nonnull
                                                                                               java.lang.String mvcId,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVC in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVC
```
public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               java.lang.String mvcType,
                                                                                               @Nonnull
                                                                                               java.util.Map<java.lang.String,java.lang.Object> args,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVC
```
public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               java.util.Map<java.lang.String,java.lang.Object> args,
                                                                                               @Nonnull
                                                                                               java.lang.String mvcType,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVC in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVC
```
public <MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                                                         java.lang.Class<? extends MVC> mvcType,
                                                                                                                         @Nonnull
                                                                                                                         MVCFunction<M,V,C> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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();
     }
 });
 
```
    Specified by:
    
    withMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVC
```
public <MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                                                         java.lang.Class<? extends MVC> mvcType,
                                                                                                                         @Nonnull
                                                                                                                         java.lang.String mvcId,
                                                                                                                         @Nonnull
                                                                                                                         MVCFunction<M,V,C> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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.
    Specified by:
    
    withMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVC
```
public <MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                                                         java.lang.Class<? extends MVC> mvcType,
                                                                                                                         @Nonnull
                                                                                                                         java.lang.String mvcId,
                                                                                                                         @Nonnull
                                                                                                                         java.util.Map<java.lang.String,java.lang.Object> args,
                                                                                                                         @Nonnull
                                                                                                                         MVCFunction<M,V,C> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVC
```
public <MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                                                         java.util.Map<java.lang.String,java.lang.Object> args,
                                                                                                                         @Nonnull
                                                                                                                         java.lang.Class<? extends MVC> mvcType,
                                                                                                                         @Nonnull
                                                                                                                         java.lang.String mvcId,
                                                                                                                         @Nonnull
                                                                                                                         MVCFunction<M,V,C> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVC in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVC
```
public <MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                                                         java.lang.Class<? extends MVC> mvcType,
                                                                                                                         @Nonnull
                                                                                                                         java.util.Map<java.lang.String,java.lang.Object> args,
                                                                                                                         @Nonnull
                                                                                                                         MVCFunction<M,V,C> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVC in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVC
```
public <MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                                                         java.util.Map<java.lang.String,java.lang.Object> args,
                                                                                                                         @Nonnull
                                                                                                                         java.lang.Class<? extends MVC> mvcType,
                                                                                                                         @Nonnull
                                                                                                                         MVCFunction<M,V,C> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVC in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVCGroup
```
public void withMVCGroup(@Nonnull
                         java.lang.String mvcType,
                         @Nonnull
                         MVCGroupFunction handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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();
     }
 });
 
```
    Specified by:
    
    withMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVCGroup
```
public void withMVCGroup(@Nonnull
                         java.lang.String mvcType,
                         @Nonnull
                         java.lang.String mvcId,
                         @Nonnull
                         MVCGroupFunction handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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.
    Specified by:
    
    withMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVCGroup
```
public void withMVCGroup(@Nonnull
                         java.lang.String mvcType,
                         @Nonnull
                         java.lang.String mvcId,
                         @Nonnull
                         java.util.Map<java.lang.String,java.lang.Object> args,
                         @Nonnull
                         MVCGroupFunction handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVCGroup
```
public void withMVCGroup(@Nonnull
                         java.util.Map<java.lang.String,java.lang.Object> args,
                         @Nonnull
                         java.lang.String mvcType,
                         @Nonnull
                         java.lang.String mvcId,
                         @Nonnull
                         MVCGroupFunction handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVCGroup in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVCGroup
```
public void withMVCGroup(@Nonnull
                         java.lang.String mvcType,
                         @Nonnull
                         java.util.Map<java.lang.String,java.lang.Object> args,
                         @Nonnull
                         MVCGroupFunction handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVCGroup
```
public void withMVCGroup(@Nonnull
                         java.util.Map<java.lang.String,java.lang.Object> args,
                         @Nonnull
                         java.lang.String mvcType,
                         @Nonnull
                         MVCGroupFunction handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVCGroup in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVCGroup
```
public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull
                                                     java.lang.Class<? extends MVC> mvcType,
                                                     @Nonnull
                                                     TypedMVCGroupFunction<MVC> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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();
     }
 });
 
```
    Specified by:
    
    withMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVCGroup
```
public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull
                                                     java.lang.Class<? extends MVC> mvcType,
                                                     @Nonnull
                                                     java.lang.String mvcId,
                                                     @Nonnull
                                                     TypedMVCGroupFunction<MVC> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    For example, with the following entry available in 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.
    Specified by:
    
    withMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVCGroup
```
public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull
                                                     java.lang.Class<? extends MVC> mvcType,
                                                     @Nonnull
                                                     java.lang.String mvcId,
                                                     @Nonnull
                                                     java.util.Map<java.lang.String,java.lang.Object> args,
                                                     @Nonnull
                                                     TypedMVCGroupFunction<MVC> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVCGroup
```
public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull
                                                     java.util.Map<java.lang.String,java.lang.Object> args,
                                                     @Nonnull
                                                     java.lang.Class<? extends MVC> mvcType,
                                                     @Nonnull
                                                     java.lang.String mvcId,
                                                     @Nonnull
                                                     TypedMVCGroupFunction<MVC> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVCGroup in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    mvcId - the name to assign to the built group.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVCGroup
```
public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull
                                                     java.lang.Class<? extends MVC> mvcType,
                                                     @Nonnull
                                                     java.util.Map<java.lang.String,java.lang.Object> args,
                                                     @Nonnull
                                                     TypedMVCGroupFunction<MVC> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVCGroup in interface MVCHandler
    
    Parameters:
    
    mvcType - the type of group to build.
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    handler - a code block used to configure and manage the instantiated group
  - withMVCGroup
```
public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull
                                                     java.util.Map<java.lang.String,java.lang.Object> args,
                                                     @Nonnull
                                                     java.lang.Class<? extends MVC> mvcType,
                                                     @Nonnull
                                                     TypedMVCGroupFunction<MVC> handler)
```
    Description copied from interface: MVCHandler
    Instantiates an MVC group of the specified type then destroys it after it has been handled.
    
    This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.
    
    MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.
    The args Map can contain any value that will be used in one of the following scenarios
    - The key matches a member definition; the value will be used as the instance of such member.
    - The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
    Specified by:
    
    withMVCGroup in interface MVCHandler
    
    Parameters:
    
    args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.
    
    mvcType - the type of group to build.
    
    handler - a code block used to configure and manage the instantiated group

Class DelegatingMVCGroup

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DelegatingMVCGroup

Method Detail

delegate

getConfiguration

getMvcType

getMvcId

getModel

getView

getController

getMember

getMembers

destroy

isAlive

getContext

getParentGroup

getChildrenGroups

notifyMVCGroupDestroyed

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVC

createMVC

createMVC

createMVC

createMVC

createMVC

createMVC

createMVC

createMVC

createMVC

createMVC

createMVC

destroyMVCGroup

withMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVCGroup

withMVCGroup

withMVCGroup

withMVCGroup

withMVCGroup

withMVCGroup

withMVCGroup

withMVCGroup

withMVCGroup

withMVCGroup

withMVCGroup

withMVCGroup