AbstractMVCGroupManager (Griffon 2.14.0)

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

All Implemented Interfaces:

MVCGroupManager, MVCHandler

Direct Known Subclasses:

DefaultMVCGroupManager
```
public abstract class AbstractMVCGroupManager
extends java.lang.Object
implements MVCGroupManager
```
Base implementation of the MVCGroupManager interface.

Since:

2.0.0

Author:

Andres Almiray

Field Summary

Fields
Modifier and Type	Field and Description
`protected static java.lang.String`	`ERROR_ARGS_NULL`
`protected static java.lang.String`	`ERROR_CONFIG_NULL`
`protected static java.lang.String`	`ERROR_CONFIGURATION_NULL`
`protected static java.lang.String`	`ERROR_GROUP_NULL`
`protected static java.lang.String`	`ERROR_MVCID_BLANK`
`protected static java.lang.String`	`ERROR_MVCTYPE_BLANK`
`protected static java.lang.String`	`ERROR_NAME_BLANK`
`protected static java.lang.String`	`ERROR_TYPE_NULL`

Constructor Summary

Constructors
Constructor and Description

AbstractMVCGroupManager(GriffonApplication application)

Constructors
Constructor and Description
`AbstractMVCGroupManager(GriffonApplication application)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addConfiguration(MVCGroupConfiguration configuration)`
`protected void`	`addGroup(MVCGroup group)`
`MVCGroupConfiguration`	`cloneMVCGroupConfiguration(java.lang.String mvcType, java.util.Map<java.lang.String,java.lang.Object> config)` Clones an existing MVCGroupConfiguration, optionally overriding additional config values.
`<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.
`protected java.util.List<? extends GriffonMvcArtifact>`	`createMVC(MVCGroupConfiguration configuration, java.lang.String mvcId, java.util.Map<java.lang.String,java.lang.Object> args)`
`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.
`protected abstract MVCGroup`	`createMVCGroup(MVCGroupConfiguration configuration, java.lang.String mvcId, java.util.Map<java.lang.String,java.lang.Object> args)`
`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.
`protected abstract void`	`doInitialize(java.util.Map<java.lang.String,MVCGroupConfiguration> configurations)`
`MVCGroupConfiguration`	`findConfiguration(java.lang.String mvcType)`
`<C extends GriffonController> C`	`findController(java.lang.String name, java.lang.Class<C> type)` Finds a named controller.
`MVCGroup`	`findGroup(java.lang.String mvcId)`
`<M extends GriffonModel> M`	`findModel(java.lang.String name, java.lang.Class<M> type)` Finds a named model.
`<V extends GriffonView> V`	`findView(java.lang.String name, java.lang.Class<V> type)` Finds a named view.
`GriffonApplication`	`getApplication()`
`MVCGroup`	`getAt(java.lang.String mvcId)`
`java.util.Map<java.lang.String,MVCGroupConfiguration>`	`getConfigurations()`
`<C extends GriffonController> C`	`getController(java.lang.String name, java.lang.Class<C> type)` Finds a named controller.
`java.util.Map<java.lang.String,? extends GriffonController>`	`getControllers()` Returns all currently available controller instances, keyed by group name.
`java.util.Map<java.lang.String,MVCGroup>`	`getGroups()`
`<M extends GriffonModel> M`	`getModel(java.lang.String name, java.lang.Class<M> type)` Finds a named model.
`java.util.Map<java.lang.String,? extends GriffonModel>`	`getModels()` Returns all currently available model instances, keyed by group name.
`<V extends GriffonView> V`	`getView(java.lang.String name, java.lang.Class<V> type)` Finds a named view.
`java.util.Map<java.lang.String,? extends GriffonView>`	`getViews()` Returns all currently available view instances, keyed by group name.
`void`	`initialize(java.util.Map<java.lang.String,MVCGroupConfiguration> configurations)` Initializes this manager with the group configurations provided by the application and addons.
`protected <MVC extends TypedMVCGroup> java.lang.String`	`nameOf(java.lang.Class<? extends MVC> mvcType)`
`Context`	`newContext(MVCGroup parentGroup)`
`MVCGroup`	`newMVCGroup(MVCGroupConfiguration configuration, java.lang.String mvcId, java.util.Map<java.lang.String,java.lang.Object> members, MVCGroup parentGroup)` Creates a new MVCGroup instance.
`MVCGroupConfiguration`	`newMVCGroupConfiguration(java.lang.String mvcType, java.util.Map<java.lang.String,java.lang.String> members, java.util.Map<java.lang.String,java.lang.Object> config)` Creates an MVCConfiguration instance with the given arguments.
`void`	`removeConfiguration(MVCGroupConfiguration configuration)`
`void`	`removeConfiguration(java.lang.String name)`
`protected void`	`removeGroup(MVCGroup group)`
`protected <MVC extends TypedMVCGroup> MVC`	`typedMvcGroup(java.lang.Class<? extends MVC> mvcType, MVCGroup mvcGroup)`
`<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.
`protected <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void`	`withMVCGroup(MVCGroupConfiguration configuration, java.lang.String mvcId, java.util.Map<java.lang.String,java.lang.Object> args, MVCFunction<M,V,C> handler)`
`protected void`	`withMVCGroup(MVCGroupConfiguration configuration, java.lang.String mvcId, java.util.Map<java.lang.String,java.lang.Object> args, MVCGroupFunction handler)`
`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

Methods inherited from interface griffon.core.mvc.MVCHandler
destroyMVCGroup

- Field Detail
  - ERROR_MVCTYPE_BLANK
```
protected static final java.lang.String ERROR_MVCTYPE_BLANK
```
    See Also:
    
    Constant Field Values
  - ERROR_MVCID_BLANK
```
protected static final java.lang.String ERROR_MVCID_BLANK
```
    See Also:
    
    Constant Field Values
  - ERROR_CONFIGURATION_NULL
```
protected static final java.lang.String ERROR_CONFIGURATION_NULL
```
    See Also:
    
    Constant Field Values
  - ERROR_GROUP_NULL
```
protected static final java.lang.String ERROR_GROUP_NULL
```
    See Also:
    
    Constant Field Values
  - ERROR_CONFIG_NULL
```
protected static final java.lang.String ERROR_CONFIG_NULL
```
    See Also:
    
    Constant Field Values
  - ERROR_ARGS_NULL
```
protected static final java.lang.String ERROR_ARGS_NULL
```
    See Also:
    
    Constant Field Values
  - ERROR_NAME_BLANK
```
protected static final java.lang.String ERROR_NAME_BLANK
```
    See Also:
    
    Constant Field Values
  - ERROR_TYPE_NULL
```
protected static final java.lang.String ERROR_TYPE_NULL
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - AbstractMVCGroupManager
```
@Inject
public AbstractMVCGroupManager(@Nonnull
                                       GriffonApplication application)
```
- Method Detail
  - getApplication
```
public GriffonApplication getApplication()
```
    Specified by:
    
    getApplication in interface MVCGroupManager
  - newMVCGroupConfiguration
```
@Nonnull
public MVCGroupConfiguration newMVCGroupConfiguration(@Nonnull
                                                               java.lang.String mvcType,
                                                               @Nonnull
                                                               java.util.Map<java.lang.String,java.lang.String> members,
                                                               @Nonnull
                                                               java.util.Map<java.lang.String,java.lang.Object> config)
```
    Description copied from interface: MVCGroupManager
    
    Creates an MVCConfiguration instance with the given arguments.
    
    Specified by:
    
    newMVCGroupConfiguration in interface MVCGroupManager
    
    Parameters:
    
    mvcType - the name of the MVC group
    
    members - members of the group
    
    config - additional configuration required by the group
    
    Returns:
    
    a ready-to-use MVCGroupConfiguration instance
  - newMVCGroup
```
@Nonnull
public MVCGroup newMVCGroup(@Nonnull
                                     MVCGroupConfiguration configuration,
                                     @Nullable
                                     java.lang.String mvcId,
                                     @Nonnull
                                     java.util.Map<java.lang.String,java.lang.Object> members,
                                     @Nullable
                                     MVCGroup parentGroup)
```
    Description copied from interface: MVCGroupManager
    
    Creates a new MVCGroup instance.
    
    Specified by:
    
    newMVCGroup in interface MVCGroupManager
    
    Parameters:
    
    configuration - the configuration of the group
    
    mvcId - the id to use for the group
    
    members - the instance members of the group
    
    parentGroup - the parent group (if any)
    
    Returns:
    
    a ready-to-use MVCGroup instance
  - newContext
```
@Nonnull
public Context newContext(@Nullable
                                   MVCGroup parentGroup)
```
    Specified by:
    
    newContext in interface MVCGroupManager
  - getConfigurations
```
@Nonnull
public java.util.Map<java.lang.String,MVCGroupConfiguration> getConfigurations()
```
    Specified by:
    
    getConfigurations in interface MVCGroupManager
  - getGroups
```
@Nonnull
public java.util.Map<java.lang.String,MVCGroup> getGroups()
```
    Specified by:
    
    getGroups in interface MVCGroupManager
  - findConfiguration
```
@Nonnull
public MVCGroupConfiguration findConfiguration(@Nonnull
                                                        java.lang.String mvcType)
```
    Specified by:
    
    findConfiguration in interface MVCGroupManager
  - findGroup
```
@Nullable
public MVCGroup findGroup(@Nonnull
                                    java.lang.String mvcId)
```
    Specified by:
    
    findGroup in interface MVCGroupManager
  - getAt
```
@Nullable
public MVCGroup getAt(@Nonnull
                                java.lang.String mvcId)
```
    Specified by:
    
    getAt in interface MVCGroupManager
  - initialize
```
public final void initialize(@Nonnull
                             java.util.Map<java.lang.String,MVCGroupConfiguration> configurations)
```
    Description copied from interface: MVCGroupManager
    
    Initializes this manager with the group configurations provided by the application and addons.
    
    Specified by:
    
    initialize in interface MVCGroupManager
    
    Parameters:
    
    configurations - available group configurations
  - addConfiguration
```
public void addConfiguration(@Nonnull
                             MVCGroupConfiguration configuration)
```
    Specified by:
    
    addConfiguration in interface MVCGroupManager
  - removeConfiguration
```
public void removeConfiguration(@Nonnull
                                MVCGroupConfiguration configuration)
```
    Specified by:
    
    removeConfiguration in interface MVCGroupManager
  - removeConfiguration
```
public void removeConfiguration(@Nonnull
                                java.lang.String name)
```
    Specified by:
    
    removeConfiguration in interface MVCGroupManager
  - addGroup
```
protected void addGroup(@Nonnull
                        MVCGroup group)
```
  - removeGroup
```
protected void removeGroup(@Nonnull
                           MVCGroup group)
```
  - getModels
```
@Nonnull
public final java.util.Map<java.lang.String,? extends GriffonModel> getModels()
```
    Description copied from interface: MVCGroupManager
    
    Returns all currently available model instances, keyed by group name.
    
    Specified by:
    
    getModels in interface MVCGroupManager
    
    Returns:
    
    a Map of all currently instantiated models.
  - getViews
```
@Nonnull
public final java.util.Map<java.lang.String,? extends GriffonView> getViews()
```
    Description copied from interface: MVCGroupManager
    
    Returns all currently available view instances, keyed by group name.
    
    Specified by:
    
    getViews in interface MVCGroupManager
    
    Returns:
    
    a Map of all currently instantiated views.
  - getControllers
```
@Nonnull
public final java.util.Map<java.lang.String,? extends GriffonController> getControllers()
```
    Description copied from interface: MVCGroupManager
    
    Returns all currently available controller instances, keyed by group name.
    
    Specified by:
    
    getControllers in interface MVCGroupManager
    
    Returns:
    
    a Map of all currently instantiated controllers.
  - cloneMVCGroupConfiguration
```
@Nonnull
public MVCGroupConfiguration cloneMVCGroupConfiguration(@Nonnull
                                                                 java.lang.String mvcType,
                                                                 @Nonnull
                                                                 java.util.Map<java.lang.String,java.lang.Object> config)
```
    Description copied from interface: MVCGroupManager
    
    Clones an existing MVCGroupConfiguration, optionally overriding additional config values.
    
    Specified by:
    
    cloneMVCGroupConfiguration in interface MVCGroupManager
    
    Parameters:
    
    mvcType - the name of the configuration to clone
    
    config - additional config parameters to be set on the configuration
    
    Returns:
    
    a ready-to-use MVCGroupConfiguration instance
  - createMVC
```
@Nonnull
protected java.util.List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                          MVCGroupConfiguration configuration,
                                                                          @Nullable
                                                                          java.lang.String mvcId,
                                                                          @Nonnull
                                                                          java.util.Map<java.lang.String,java.lang.Object> args)
```
  - withMVCGroup
```
protected <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVCGroup(@Nonnull
                                                                                                       MVCGroupConfiguration configuration,
                                                                                                       @Nullable
                                                                                                       java.lang.String mvcId,
                                                                                                       @Nonnull
                                                                                                       java.util.Map<java.lang.String,java.lang.Object> args,
                                                                                                       @Nonnull
                                                                                                       MVCFunction<M,V,C> handler)
```
  - withMVCGroup
```
protected void withMVCGroup(@Nonnull
                            MVCGroupConfiguration configuration,
                            @Nullable
                            java.lang.String mvcId,
                            @Nonnull
                            java.util.Map<java.lang.String,java.lang.Object> args,
                            @Nonnull
                            MVCGroupFunction handler)
```
  - createMVCGroup
```
@Nonnull
protected abstract MVCGroup createMVCGroup(@Nonnull
                                                    MVCGroupConfiguration configuration,
                                                    @Nullable
                                                    java.lang.String mvcId,
                                                    @Nonnull
                                                    java.util.Map<java.lang.String,java.lang.Object> args)
```
  - doInitialize
```
protected abstract void doInitialize(@Nonnull
                                     java.util.Map<java.lang.String,MVCGroupConfiguration> configurations)
```
  - 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
  - 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
  - getController
```
@Nonnull
public <C extends GriffonController> C getController(@Nonnull
                                                              java.lang.String name,
                                                              @Nonnull
                                                              java.lang.Class<C> type)
                                                       throws ArtifactNotFoundException
```
    Description copied from interface: MVCGroupManager
    
    Finds a named controller.
    
    Specified by:
    
    getController in interface MVCGroupManager
    
    Parameters:
    
    name - the name of the group that holds the controller
    
    type - the type of the controller
    
    Returns:
    
    the controller instance if found
    
    Throws:
    
    ArtifactNotFoundException - if the named controller could not be found
  - getModel
```
@Nonnull
public <M extends GriffonModel> M getModel(@Nonnull
                                                    java.lang.String name,
                                                    @Nonnull
                                                    java.lang.Class<M> type)
                                             throws ArtifactNotFoundException
```
    Description copied from interface: MVCGroupManager
    
    Finds a named model.
    
    Specified by:
    
    getModel in interface MVCGroupManager
    
    Parameters:
    
    name - the name of the group that holds the model
    
    type - the type of the model
    
    Returns:
    
    the model instance if found
    
    Throws:
    
    ArtifactNotFoundException - if the named model could not be found
  - getView
```
@Nonnull
public <V extends GriffonView> V getView(@Nonnull
                                                  java.lang.String name,
                                                  @Nonnull
                                                  java.lang.Class<V> type)
                                           throws ArtifactNotFoundException
```
    Description copied from interface: MVCGroupManager
    
    Finds a named view.
    
    Specified by:
    
    getView in interface MVCGroupManager
    
    Parameters:
    
    name - the name of the group that holds the view
    
    type - the type of the view
    
    Returns:
    
    the view instance if found
    
    Throws:
    
    ArtifactNotFoundException - if the named view could not be found
  - findController
```
@Nullable
public <C extends GriffonController> C findController(@Nonnull
                                                                java.lang.String name,
                                                                @Nonnull
                                                                java.lang.Class<C> type)
```
    Description copied from interface: MVCGroupManager
    
    Finds a named controller.
    
    Specified by:
    
    findController in interface MVCGroupManager
    
    Parameters:
    
    name - the name of the group that holds the controller
    
    type - the type of the controller
    
    Returns:
    
    the controller instance if found
  - findModel
```
@Nullable
public <M extends GriffonModel> M findModel(@Nonnull
                                                      java.lang.String name,
                                                      @Nonnull
                                                      java.lang.Class<M> type)
```
    Description copied from interface: MVCGroupManager
    
    Finds a named model.
    
    Specified by:
    
    findModel in interface MVCGroupManager
    
    Parameters:
    
    name - the name of the group that holds the model
    
    type - the type of the model
    
    Returns:
    
    the model instance if found
  - findView
```
@Nullable
public <V extends GriffonView> V findView(@Nonnull
                                                    java.lang.String name,
                                                    @Nonnull
                                                    java.lang.Class<V> type)
```
    Description copied from interface: MVCGroupManager
    
    Finds a named view.
    
    Specified by:
    
    findView in interface MVCGroupManager
    
    Parameters:
    
    name - the name of the group that holds the view
    
    type - the type of the view
    
    Returns:
    
    the view instance if found
  - nameOf
```
@Nonnull
protected <MVC extends TypedMVCGroup> java.lang.String nameOf(@Nonnull
                                                                       java.lang.Class<? extends MVC> mvcType)
```
  - typedMvcGroup
```
@Nonnull
protected <MVC extends TypedMVCGroup> MVC typedMvcGroup(@Nonnull
                                                                 java.lang.Class<? extends MVC> mvcType,
                                                                 @Nonnull
                                                                 MVCGroup mvcGroup)
```

Class AbstractMVCGroupManager

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface griffon.core.mvc.MVCHandler

Field Detail

ERROR_MVCTYPE_BLANK

ERROR_MVCID_BLANK

ERROR_CONFIGURATION_NULL

ERROR_GROUP_NULL

ERROR_CONFIG_NULL

ERROR_ARGS_NULL

ERROR_NAME_BLANK

ERROR_TYPE_NULL

Constructor Detail

AbstractMVCGroupManager

Method Detail

getApplication

newMVCGroupConfiguration

newMVCGroup

newContext

getConfigurations

getGroups

findConfiguration

findGroup

getAt

initialize

addConfiguration

removeConfiguration

removeConfiguration

addGroup

removeGroup

getModels

getViews

getControllers

cloneMVCGroupConfiguration

createMVC

withMVCGroup

withMVCGroup

createMVCGroup

doInitialize

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVCGroup

createMVC

createMVC

createMVC

createMVC

createMVC

createMVC

createMVC

createMVC

createMVC

createMVC

createMVC

createMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVC

withMVCGroup

withMVCGroup