public abstract class AbstractMVCGroup extends AbstractMVCHandler implements MVCGroup
MVCGroup interface| Modifier and Type | Field and Description |
|---|---|
protected MVCGroupConfiguration |
configuration |
protected Map<String,Object> |
members |
protected String |
mvcId |
| Constructor and Description |
|---|
AbstractMVCGroup(MVCGroupManager mvcGroupManager,
MVCGroupConfiguration configuration,
String mvcId,
Map<String,Object> members) |
| Modifier and Type | Method and Description |
|---|---|
protected void |
checkIfAlive() |
List<? extends GriffonMvcArtifact> |
createMVC(Map<String,Object> args,
String mvcType)
Instantiates an MVC group of the specified type with additional variables.
|
List<? extends GriffonMvcArtifact> |
createMVC(Map<String,Object> args,
String mvcType,
String mvcId)
Instantiates an MVC group of the specified type with a particular name.
|
List<? extends GriffonMvcArtifact> |
createMVC(String mvcType)
Instantiates an MVC group of the specified type returning only the MVC parts.
|
List<? extends GriffonMvcArtifact> |
createMVC(String mvcType,
Map<String,Object> args)
Instantiates an MVC group of the specified type with additional variables.
|
List<? extends GriffonMvcArtifact> |
createMVC(String mvcType,
String mvcId)
Instantiates an MVC group of the specified type with a particular name.
|
List<? extends GriffonMvcArtifact> |
createMVC(String mvcType,
String mvcId,
Map<String,Object> args)
Instantiates an MVC group of the specified type with a particular name.
|
MVCGroup |
createMVCGroup(Map<String,Object> args,
String mvcType)
Instantiates an MVC group of the specified type with additional variables.
|
MVCGroup |
createMVCGroup(Map<String,Object> args,
String mvcType,
String mvcId)
Instantiates an MVC group of the specified type with a particular name.
|
MVCGroup |
createMVCGroup(String mvcType)
Instantiates an MVC group of the specified type.
|
MVCGroup |
createMVCGroup(String mvcType,
Map<String,Object> args)
Instantiates an MVC group of the specified type with additional variables.
|
MVCGroup |
createMVCGroup(String mvcType,
String mvcId)
Instantiates an MVC group of the specified type with a particular name.
|
MVCGroup |
createMVCGroup(String mvcType,
String mvcId,
Map<String,Object> args)
Instantiates an MVC group of the specified type with a particular name.
|
void |
destroy()
Destroys the current group.
|
MVCGroupConfiguration |
getConfiguration()
Returns the configuration of this group.
|
GriffonController |
getController()
Returns the Controller portion of this group.
|
Object |
getMember(String name)
Returns the specified member type.
|
Map<String,Object> |
getMembers()
Returns a read-only view of all instance members.
|
GriffonModel |
getModel()
Returns the Model portion of this group.
|
String |
getMvcId()
Returns the id of the group.
|
String |
getMvcType()
Returns the type of this group as set in the application's configuration.
|
GriffonView |
getView()
Returns the View portion of this group.
|
boolean |
isAlive()
Returns whether this group has been destroyed or not.
|
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> |
withMVC(Map<String,Object> args,
String mvcType,
MVCFunction<M,V,C> handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> |
withMVC(Map<String,Object> args,
String mvcType,
String mvcId,
MVCFunction<M,V,C> handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> |
withMVC(String mvcType,
Map<String,Object> args,
MVCFunction<M,V,C> handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> |
withMVC(String mvcType,
MVCFunction<M,V,C> handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> |
withMVC(String mvcType,
String mvcId,
Map<String,Object> args,
MVCFunction<M,V,C> handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> |
withMVC(String mvcType,
String mvcId,
MVCFunction<M,V,C> handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
void |
withMVCGroup(Map<String,Object> args,
String mvcType,
MVCGroupFunction handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
void |
withMVCGroup(Map<String,Object> args,
String mvcType,
String mvcId,
MVCGroupFunction handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
void |
withMVCGroup(String mvcType,
Map<String,Object> args,
MVCGroupFunction handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
void |
withMVCGroup(String mvcType,
MVCGroupFunction handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
void |
withMVCGroup(String mvcType,
String mvcId,
Map<String,Object> args,
MVCGroupFunction handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
void |
withMVCGroup(String mvcType,
String mvcId,
MVCGroupFunction handler)
Instantiates an MVC group of the specified type then destroys it after it has been handled.
|
destroyMVCGroup, getMvcGroupManagerclone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitdestroyMVCGroupprotected final MVCGroupConfiguration configuration
protected final String mvcId
public AbstractMVCGroup(@Nonnull MVCGroupManager mvcGroupManager, @Nonnull MVCGroupConfiguration configuration, @Nullable String mvcId, @Nonnull Map<String,Object> members)
@Nonnull public MVCGroupConfiguration getConfiguration()
MVCGroupgetConfiguration in interface MVCGroup@Nonnull public String getMvcType()
MVCGroupgetMvcType in interface MVCGroup@Nonnull public String getMvcId()
MVCGroup@Nullable public GriffonModel getModel()
MVCGroup@Nullable public GriffonView getView()
MVCGroup@Nullable public GriffonController getController()
MVCGroupgetController in interface MVCGroup@Nullable public Object getMember(@Nonnull String name)
MVCGroup@Nonnull public Map<String,Object> getMembers()
MVCGroupgetMembers in interface MVCGrouppublic void destroy()
MVCGrouppublic boolean isAlive()
MVCGroupprotected void checkIfAlive()
@Nonnull public MVCGroup createMVCGroup(@Nonnull Map<String,Object> args, @Nonnull String mvcType)
MVCHandlerMVC 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
Application.groovy
mvcGroups {
'foo' {
model = 'com.acme.FooModel'
view = 'com.acme.FooView'
controller = 'com.acme.FooController'
}
'bar' {
model = 'com.acme.FooModel'
view = 'com.acme.BarView'
controller = 'com.acme.BarController'
}
}
Notice that groups "foo" and "bar share the same model type, We can make them share the same model
instance by creating the groups in the following way:
MVCGroup fooGroup = createMVCGroup('foo')
MVCGroup barGroup = createMVCGroup('bar', model: fooGroup.model)
assert fooGroup.model == barGroup.model
createMVCGroup in interface MVCHandlercreateMVCGroup in class AbstractMVCHandlerargs - 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.@Nonnull public MVCGroup createMVCGroup(@Nonnull Map<String,Object> args, @Nonnull String mvcType, @Nonnull String mvcId)
MVCHandlerMVC 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
Application.groovy
mvcGroups {
'foo' {
model = 'com.acme.FooModel'
view = 'com.acme.FooView'
controller = 'com.acme.FooController'
}
}
We can create two instances of the same group that share the same model instance in the following way:
MVCGroup fooGroup1 = createMVCGroup('foo', 'foo1')
MVCGroup fooGroup2 = createMVCGroup('bar', 'foo2', model: fooGroup1.model)
assert fooGroup1.model == fooGroup2.model
MVC groups must have an unique name.createMVCGroup in interface MVCHandlercreateMVCGroup in class AbstractMVCHandlerargs - 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.@Nonnull public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull Map<String,Object> args)
MVCHandlerMVC 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
Application.groovy
mvcGroups {
'foo' {
model = 'com.acme.FooModel'
view = 'com.acme.FooView'
controller = 'com.acme.FooController'
}
'bar' {
model = 'com.acme.FooModel'
view = 'com.acme.BarView'
controller = 'com.acme.BarController'
}
}
Notice that groups "foo" and "bar share the same model type, We can make them share the same model
instance by creating the groups in the following way:
MVCGroup fooGroup = createMVCGroup('foo')
MVCGroup barGroup = createMVCGroup('bar', model: fooGroup.model)
assert fooGroup.model == barGroup.model
createMVCGroup in interface MVCHandlercreateMVCGroup in class AbstractMVCHandlermvcType - 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.@Nonnull public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String,Object> args)
MVCHandlerMVC 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
Application.groovy
mvcGroups {
'foo' {
model = 'com.acme.FooModel'
view = 'com.acme.FooView'
controller = 'com.acme.FooController'
}
}
We can create two instances of the same group that share the same model instance in the following way:
MVCGroup fooGroup1 = createMVCGroup('foo', 'foo1')
MVCGroup fooGroup2 = createMVCGroup('bar', 'foo2', model: fooGroup1.model)
assert fooGroup1.model == fooGroup2.model
MVC groups must have an unique name.createMVCGroup in interface MVCHandlercreateMVCGroup in class AbstractMVCHandlermvcType - 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.@Nonnull public List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String,Object> args, @Nonnull String mvcType)
MVCHandlerMVC 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
Application.groovy
mvcGroups {
'foo' {
model = 'com.acme.FooModel'
view = 'com.acme.FooView'
controller = 'com.acme.FooController'
}
'bar' {
model = 'com.acme.FooModel'
view = 'com.acme.BarView'
controller = 'com.acme.BarController'
}
}
Notice that groups "foo" and "bar share the same model type, We can make them share the same model
instance by creating the groups in the following way:
def (m1, v1, c1) = createMVC('foo')
def (m2, v2, c2) = createMVC('bar', model: m1)
assert fm1 == m2
createMVC in interface MVCHandlercreateMVC in class AbstractMVCHandlerargs - 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.@Nonnull public List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String,Object> args, @Nonnull String mvcType, @Nonnull String mvcId)
MVCHandlerMVC 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
Application.groovy
mvcGroups {
'foo' {
model = 'com.acme.FooModel'
view = 'com.acme.FooView'
controller = 'com.acme.FooController'
}
}
We can create two instances of the same group that share the same model instance in the following way:
def (m1, v1, c1) = createMVC('foo', 'foo1')
def (m2, v2, c2) = createMVC('foo', 'foo2', model: m1)
assert fm1 == m2
MVC groups must have an unique name.createMVC in interface MVCHandlercreateMVC in class AbstractMVCHandlerargs - 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.@Nonnull public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull Map<String,Object> args)
MVCHandlerMVC 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
Application.groovy
mvcGroups {
'foo' {
model = 'com.acme.FooModel'
view = 'com.acme.FooView'
controller = 'com.acme.FooController'
}
'bar' {
model = 'com.acme.FooModel'
view = 'com.acme.BarView'
controller = 'com.acme.BarController'
}
}
Notice that groups "foo" and "bar share the same model type, We can make them share the same model
instance by creating the groups in the following way:
def (m1, v1, c1) = createMVC('foo')
def (m2, v2, c2) = createMVC('bar', model: m1)
assert fm1 == m2
createMVC in interface MVCHandlercreateMVC in class AbstractMVCHandlermvcType - 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.@Nonnull public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String,Object> args)
MVCHandlerMVC 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
Application.groovy
mvcGroups {
'foo' {
model = 'com.acme.FooModel'
view = 'com.acme.FooView'
controller = 'com.acme.FooController'
}
}
We can create two instances of the same group that share the same model instance in the following way:
def (m1, v1, c1) = createMVC('foo', 'foo1')
def (m2, v2, c2) = createMVC('foo', 'foo2', model: m1)
assert fm1 == m2
MVC groups must have an unique name.createMVC in interface MVCHandlercreateMVC in class AbstractMVCHandlermvcType - 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.public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull Map<String,Object> args, @Nonnull String mvcType, @Nonnull MVCFunction<M,V,C> handler)
MVCHandler
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 scenariosApplication.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