AbstractGriffonMvcArtifact.java
001 /*
002  * SPDX-License-Identifier: Apache-2.0
003  *
004  * Copyright 2008-2017 the original author or authors.
005  *
006  * Licensed under the Apache License, Version 2.0 (the "License");
007  * you may not use this file except in compliance with the License.
008  * You may obtain a copy of the License at
009  *
010  *     http://www.apache.org/licenses/LICENSE-2.0
011  *
012  * Unless required by applicable law or agreed to in writing, software
013  * distributed under the License is distributed on an "AS IS" BASIS,
014  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015  * See the License for the specific language governing permissions and
016  * limitations under the License.
017  */
018 package org.codehaus.griffon.runtime.core.artifact;
019 
020 import griffon.core.GriffonApplication;
021 import griffon.core.artifact.GriffonController;
022 import griffon.core.artifact.GriffonModel;
023 import griffon.core.artifact.GriffonMvcArtifact;
024 import griffon.core.artifact.GriffonView;
025 import griffon.core.mvc.MVCFunction;
026 import griffon.core.mvc.MVCGroup;
027 import griffon.core.mvc.MVCGroupFunction;
028 import griffon.core.mvc.TypedMVCGroup;
029 import griffon.core.mvc.TypedMVCGroupFunction;
030 import griffon.inject.MVCMember;
031 
032 import javax.annotation.Nonnull;
033 import javax.inject.Inject;
034 import java.util.List;
035 import java.util.Map;
036 
037 import static java.util.Objects.requireNonNull;
038 
039 /**
040  * Base implementation of the GriffonMvcArtifact interface.
041  *
042  @author Andres Almiray
043  @since 2.0.0
044  */
045 public abstract class AbstractGriffonMvcArtifact extends AbstractGriffonArtifact implements GriffonMvcArtifact {
046     private MVCGroup group;
047 
048     public AbstractGriffonMvcArtifact() {
049 
050     }
051 
052     /**
053      * Creates a new instance of this class.
054      *
055      @param application the GriffonApplication that holds this artifact.
056      *
057      @deprecated Griffon prefers field injection over constructor injector for artifacts as of 2.1.0
058      */
059     @Inject
060     @Deprecated
061     public AbstractGriffonMvcArtifact(@Nonnull GriffonApplication application) {
062         super(application);
063     }
064 
065     @MVCMember
066     public void setMvcGroup(@Nonnull MVCGroup group) {
067         this.group = requireNonNull(group, "Argument 'group' must not be null");
068     }
069 
070     @Nonnull
071     @Override
072     public MVCGroup getMvcGroup() {
073         return group;
074     }
075 
076     public void mvcGroupInit(@Nonnull Map<String, Object> args) {
077         // empty
078     }
079 
080     public void mvcGroupDestroy() {
081         // empty
082     }
083 
084     @Override
085     @Nonnull
086     public MVCGroup createMVCGroup(@Nonnull String mvcType) {
087         return group.createMVCGroup(mvcType);
088     }
089 
090     @Override
091     @Nonnull
092     public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId) {
093         return group.createMVCGroup(mvcType, mvcId);
094     }
095 
096     @Override
097     @Nonnull
098     public MVCGroup createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType) {
099         return group.createMVCGroup(args, mvcType);
100     }
101 
102     @Override
103     @Nonnull
104     public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull Map<String, Object> args) {
105         return group.createMVCGroup(mvcType, args);
106     }
107 
108     @Override
109     @Nonnull
110     public MVCGroup createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId) {
111         return group.createMVCGroup(args, mvcType, mvcId);
112     }
113 
114     @Override
115     @Nonnull
116     public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
117         return group.createMVCGroup(mvcType, mvcId, args);
118     }
119 
120     @Override
121     @Nonnull
122     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType) {
123         return group.createMVCGroup(mvcType);
124     }
125 
126     @Override
127     @Nonnull
128     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
129         return group.createMVCGroup(mvcType, mvcId);
130     }
131 
132     @Override
133     @Nonnull
134     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType) {
135         return group.createMVCGroup(args, mvcType);
136     }
137 
138     @Override
139     @Nonnull
140     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String, Object> args) {
141         return group.createMVCGroup(mvcType, args);
142     }
143 
144     @Override
145     @Nonnull
146     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
147         return group.createMVCGroup(args, mvcType, mvcId);
148     }
149 
150     @Override
151     @Nonnull
152     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
153         return group.createMVCGroup(mvcType, mvcId, args);
154     }
155 
156     @Override
157     @Nonnull
158     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType) {
159         return group.createMVC(mvcType);
160     }
161 
162     @Override
163     @Nonnull
164     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull String mvcType) {
165         return group.createMVC(args, mvcType);
166     }
167 
168     @Override
169     @Nonnull
170     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull Map<String, Object> args) {
171         return group.createMVC(mvcType, args);
172     }
173 
174     @Override
175     @Nonnull
176     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull String mvcId) {
177         return group.createMVC(mvcType, mvcId);
178     }
179 
180     @Override
181     @Nonnull
182     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId) {
183         return group.createMVC(args, mvcType, mvcId);
184     }
185 
186     @Override
187     @Nonnull
188     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
189         return group.createMVC(mvcType, mvcId, args);
190     }
191 
192     @Override
193     @Nonnull
194     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType) {
195         return group.createMVC(mvcType);
196     }
197 
198     @Override
199     @Nonnull
200     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType) {
201         return group.createMVC(args, mvcType);
202     }
203 
204     @Override
205     @Nonnull
206     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String, Object> args) {
207         return group.createMVC(mvcType, args);
208     }
209 
210     @Override
211     @Nonnull
212     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
213         return group.createMVC(mvcType, mvcId);
214     }
215 
216     @Override
217     @Nonnull
218     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
219         return group.createMVC(args, mvcType, mvcId);
220     }
221 
222     @Override
223     @Nonnull
224     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
225         return group.createMVC(mvcType, mvcId, args);
226     }
227 
228     @Override
229     public void destroyMVCGroup(@Nonnull String mvcId) {
230         group.destroyMVCGroup(mvcId);
231     }
232 
233     @Override
234     public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull MVCFunction<M, V, C> handler) {
235         group.withMVC(mvcType, handler);
236     }
237 
238     @Override
239     public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCFunction<M, V, C> handler) {
240         group.withMVC(mvcType, mvcId, handler);
241     }
242 
243     @Override
244     public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args, @Nonnull MVCFunction<M, V, C> handler) {
245         group.withMVC(mvcType, mvcId, args, handler);
246     }
247 
248     @Override
249     public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCFunction<M, V, C> handler) {
250         group.withMVC(args, mvcType, mvcId, handler);
251     }
252 
253     @Override
254     public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull Map<String, Object> args, @Nonnull MVCFunction<M, V, C> handler) {
255         group.withMVC(mvcType, args, handler);
256     }
257 
258     @Override
259     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) {
260         group.withMVC(args, mvcType, handler);
261     }
262 
263     @Override
264     public <MVC extends TypedMVCGroup, M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull MVCFunction<M, V, C> handler) {
265         group.withMVC(mvcType, handler);
266     }
267 
268     @Override
269     public <MVC extends TypedMVCGroup, M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull MVCFunction<M, V, C> handler) {
270         group.withMVC(mvcType, mvcId, handler);
271     }
272 
273     @Override
274     public <MVC extends TypedMVCGroup, M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args, @Nonnull MVCFunction<M, V, C> handler) {
275         group.withMVC(mvcType, mvcId, args, handler);
276     }
277 
278     @Override
279     public <MVC extends TypedMVCGroup, M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull MVCFunction<M, V, C> handler) {
280         group.withMVC(args, mvcType, mvcId, handler);
281     }
282 
283     @Override
284     public <MVC extends TypedMVCGroup, M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String, Object> args, @Nonnull MVCFunction<M, V, C> handler) {
285         group.withMVC(mvcType, args, handler);
286     }
287 
288     @Override
289     public <MVC extends TypedMVCGroup, M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull MVCFunction<M, V, C> handler) {
290         group.withMVC(args, mvcType, handler);
291     }
292 
293     @Override
294     public void withMVCGroup(@Nonnull String mvcType, @Nonnull MVCGroupFunction handler) {
295         group.withMVCGroup(mvcType, handler);
296     }
297 
298     @Override
299     public void withMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCGroupFunction handler) {
300         group.withMVCGroup(mvcType, mvcId, handler);
301     }
302 
303     @Override
304     public void withMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args, @Nonnull MVCGroupFunction handler) {
305         group.withMVCGroup(mvcType, mvcId, args, handler);
306     }
307 
308     @Override
309     public void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCGroupFunction handler) {
310         group.withMVCGroup(args, mvcType, mvcId, handler);
311     }
312 
313     @Override
314     public void withMVCGroup(@Nonnull String mvcType, @Nonnull Map<String, Object> args, @Nonnull MVCGroupFunction handler) {
315         group.withMVCGroup(mvcType, args, handler);
316     }
317 
318     @Override
319     public void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull MVCGroupFunction handler) {
320         group.withMVCGroup(args, mvcType, handler);
321     }
322 
323     @Override
324     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull TypedMVCGroupFunction<MVC> handler) {
325         group.withMVCGroup(mvcType, handler);
326     }
327 
328     @Override
329     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull TypedMVCGroupFunction<MVC> handler) {
330         group.withMVCGroup(mvcType, mvcId, handler);
331     }
332 
333     @Override
334     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args, @Nonnull TypedMVCGroupFunction<MVC> handler) {
335         group.withMVCGroup(mvcType, mvcId, args, handler);
336     }
337 
338     @Override
339     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull TypedMVCGroupFunction<MVC> handler) {
340         group.withMVCGroup(args, mvcType, mvcId, handler);
341     }
342 
343     @Override
344     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String, Object> args, @Nonnull TypedMVCGroupFunction<MVC> handler) {
345         group.withMVCGroup(mvcType, args, handler);
346     }
347 
348     @Override
349     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull TypedMVCGroupFunction<MVC> handler) {
350         group.withMVCGroup(args, mvcType, handler);
351     }
352 }