AbstractGriffonArtifact.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.GriffonArtifact;
022 import griffon.core.artifact.GriffonClass;
023 import griffon.core.artifact.GriffonController;
024 import griffon.core.artifact.GriffonModel;
025 import griffon.core.artifact.GriffonMvcArtifact;
026 import griffon.core.artifact.GriffonView;
027 import griffon.core.i18n.NoSuchMessageException;
028 import griffon.core.mvc.MVCFunction;
029 import griffon.core.mvc.MVCGroup;
030 import griffon.core.mvc.MVCGroupFunction;
031 import griffon.core.mvc.TypedMVCGroup;
032 import griffon.core.mvc.TypedMVCGroupFunction;
033 import org.slf4j.Logger;
034 import org.slf4j.LoggerFactory;
035 
036 import javax.annotation.Nonnull;
037 import javax.annotation.Nullable;
038 import javax.annotation.concurrent.GuardedBy;
039 import javax.inject.Inject;
040 import java.io.InputStream;
041 import java.net.URL;
042 import java.util.List;
043 import java.util.Map;
044 import java.util.concurrent.Callable;
045 import java.util.concurrent.ExecutorService;
046 import java.util.concurrent.Future;
047 
048 /**
049  * Base implementation of the GriffonArtifact interface.
050  *
051  @author Andres Almiray
052  @since 2.0.0
053  */
054 public abstract class AbstractGriffonArtifact implements GriffonArtifact {
055     private final Logger log;
056     private final Object lock = new Object[0];
057     @Inject
058     protected GriffonApplication application;
059     @GuardedBy("lock")
060     private GriffonClass griffonClass;
061 
062     public AbstractGriffonArtifact() {
063         log = LoggerFactory.getLogger("griffon.app." + getArtifactType() "." + getTypeClass().getName());
064     }
065 
066     @Override
067     @Nonnull
068     public Class<? extends GriffonArtifact> getTypeClass() {
069         return getClass();
070     }
071 
072     /**
073      * Creates a new instance of this class.
074      *
075      @param application the GriffonApplication that holds this artifact.
076      *
077      @deprecated Griffon prefers field injection over constructor injector for artifacts as of 2.1.0
078      */
079     @Inject
080     @Deprecated
081     public AbstractGriffonArtifact(@Nonnull GriffonApplication application) {
082         this();
083         this.application = application;
084     }
085 
086     @Nonnull
087     public GriffonApplication getApplication() {
088         return application;
089     }
090 
091     @Nonnull
092     @Override
093     @SuppressWarnings("ConstantConditions")
094     public GriffonClass getGriffonClass() {
095         synchronized (lock) {
096             if (griffonClass == null) {
097                 griffonClass = application.getArtifactManager().findGriffonClass(getTypeClass());
098             }
099             return griffonClass;
100         }
101     }
102 
103     @Nonnull
104     @Override
105     public Logger getLog() {
106         return log;
107     }
108 
109     @Nonnull
110     protected abstract String getArtifactType();
111 
112     @Override
113     public boolean isUIThread() {
114         return application.getUIThreadManager().isUIThread();
115     }
116 
117     @Nonnull
118     @Override
119     public <R> Future<R> runFuture(@Nonnull ExecutorService executorService, @Nonnull Callable<R> callable) {
120         return application.getUIThreadManager().runFuture(executorService, callable);
121     }
122 
123     @Nonnull
124     @Override
125     public <R> Future<R> runFuture(@Nonnull Callable<R> callable) {
126         return application.getUIThreadManager().runFuture(callable);
127     }
128 
129     @Override
130     public void runInsideUISync(@Nonnull Runnable runnable) {
131         application.getUIThreadManager().runInsideUISync(runnable);
132     }
133 
134     @Override
135     public void runOutsideUI(@Nonnull Runnable runnable) {
136         application.getUIThreadManager().runOutsideUI(runnable);
137     }
138 
139     @Override
140     public void runOutsideUIAsync(@Nonnull Runnable runnable) {
141         application.getUIThreadManager().runOutsideUIAsync(runnable);
142     }
143 
144     @Override
145     public void runInsideUIAsync(@Nonnull Runnable runnable) {
146         application.getUIThreadManager().runInsideUIAsync(runnable);
147     }
148 
149     @Nullable
150     @Override
151     public <R> R runInsideUISync(@Nonnull Callable<R> callable) {
152         return application.getUIThreadManager().runInsideUISync(callable);
153     }
154 
155     @Nonnull
156     @Override
157     public ClassLoader classloader() {
158         return application.getResourceHandler().classloader();
159     }
160 
161     @Nullable
162     @Override
163     public URL getResourceAsURL(@Nonnull String name) {
164         return application.getResourceHandler().getResourceAsURL(name);
165     }
166 
167     @Nullable
168     @Override
169     public List<URL> getResources(@Nonnull String name) {
170         return application.getResourceHandler().getResources(name);
171     }
172 
173     @Nullable
174     @Override
175     public InputStream getResourceAsStream(@Nonnull String name) {
176         return application.getResourceHandler().getResourceAsStream(name);
177     }
178 
179     @Override
180     @Nonnull
181     public MVCGroup createMVCGroup(@Nonnull String mvcType) {
182         return application.getMvcGroupManager().createMVCGroup(mvcType);
183     }
184 
185     @Override
186     @Nonnull
187     public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId) {
188         return application.getMvcGroupManager().createMVCGroup(mvcType, mvcId);
189     }
190 
191     @Override
192     @Nonnull
193     public MVCGroup createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType) {
194         return application.getMvcGroupManager().createMVCGroup(args, mvcType);
195     }
196 
197     @Override
198     @Nonnull
199     public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull Map<String, Object> args) {
200         return application.getMvcGroupManager().createMVCGroup(mvcType, args);
201     }
202 
203     @Override
204     @Nonnull
205     public MVCGroup createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId) {
206         return application.getMvcGroupManager().createMVCGroup(args, mvcType, mvcId);
207     }
208 
209     @Override
210     @Nonnull
211     public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
212         return application.getMvcGroupManager().createMVCGroup(mvcType, mvcId, args);
213     }
214 
215     @Override
216     @Nonnull
217     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType) {
218         return application.getMvcGroupManager().createMVCGroup(mvcType);
219     }
220 
221     @Override
222     @Nonnull
223     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
224         return application.getMvcGroupManager().createMVCGroup(mvcType, mvcId);
225     }
226 
227     @Override
228     @Nonnull
229     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType) {
230         return application.getMvcGroupManager().createMVCGroup(args, mvcType);
231     }
232 
233     @Override
234     @Nonnull
235     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String, Object> args) {
236         return application.getMvcGroupManager().createMVCGroup(mvcType, args);
237     }
238 
239     @Override
240     @Nonnull
241     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
242         return application.getMvcGroupManager().createMVCGroup(args, mvcType, mvcId);
243     }
244 
245     @Override
246     @Nonnull
247     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
248         return application.getMvcGroupManager().createMVCGroup(mvcType, mvcId, args);
249     }
250 
251     @Override
252     @Nonnull
253     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType) {
254         return application.getMvcGroupManager().createMVC(mvcType);
255     }
256 
257     @Override
258     @Nonnull
259     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull String mvcType) {
260         return application.getMvcGroupManager().createMVC(args, mvcType);
261     }
262 
263     @Override
264     @Nonnull
265     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull Map<String, Object> args) {
266         return application.getMvcGroupManager().createMVC(mvcType, args);
267     }
268 
269     @Override
270     @Nonnull
271     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull String mvcId) {
272         return application.getMvcGroupManager().createMVC(mvcType, mvcId);
273     }
274 
275     @Override
276     @Nonnull
277     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId) {
278         return application.getMvcGroupManager().createMVC(args, mvcType, mvcId);
279     }
280 
281     @Override
282     @Nonnull
283     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
284         return application.getMvcGroupManager().createMVC(mvcType, mvcId, args);
285     }
286 
287     @Override
288     @Nonnull
289     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType) {
290         return application.getMvcGroupManager().createMVC(mvcType);
291     }
292 
293     @Override
294     @Nonnull
295     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType) {
296         return application.getMvcGroupManager().createMVC(args, mvcType);
297     }
298 
299     @Override
300     @Nonnull
301     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String, Object> args) {
302         return application.getMvcGroupManager().createMVC(mvcType, args);
303     }
304 
305     @Override
306     @Nonnull
307     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
308         return application.getMvcGroupManager().createMVC(mvcType, mvcId);
309     }
310 
311     @Override
312     @Nonnull
313     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
314         return application.getMvcGroupManager().createMVC(args, mvcType, mvcId);
315     }
316 
317     @Override
318     @Nonnull
319     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
320         return application.getMvcGroupManager().createMVC(mvcType, mvcId, args);
321     }
322 
323     @Override
324     public void destroyMVCGroup(@Nonnull String mvcId) {
325         application.getMvcGroupManager().destroyMVCGroup(mvcId);
326     }
327 
328     @Override
329     public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull MVCFunction<M, V, C> handler) {
330         application.getMvcGroupManager().withMVC(mvcType, handler);
331     }
332 
333     @Override
334     public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCFunction<M, V, C> handler) {
335         application.getMvcGroupManager().withMVC(mvcType, mvcId, handler);
336     }
337 
338     @Override
339     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) {
340         application.getMvcGroupManager().withMVC(mvcType, mvcId, args, handler);
341     }
342 
343     @Override
344     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) {
345         application.getMvcGroupManager().withMVC(args, mvcType, mvcId, handler);
346     }
347 
348     @Override
349     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) {
350         application.getMvcGroupManager().withMVC(mvcType, args, handler);
351     }
352 
353     @Override
354     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) {
355         application.getMvcGroupManager().withMVC(args, mvcType, handler);
356     }
357 
358     @Override
359     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) {
360         application.getMvcGroupManager().withMVC(mvcType, handler);
361     }
362 
363     @Override
364     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) {
365         application.getMvcGroupManager().withMVC(mvcType, mvcId, handler);
366     }
367 
368     @Override
369     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) {
370         application.getMvcGroupManager().withMVC(mvcType, mvcId, args, handler);
371     }
372 
373     @Override
374     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) {
375         application.getMvcGroupManager().withMVC(args, mvcType, mvcId, handler);
376     }
377 
378     @Override
379     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) {
380         application.getMvcGroupManager().withMVC(mvcType, args, handler);
381     }
382 
383     @Override
384     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) {
385         application.getMvcGroupManager().withMVC(args, mvcType, handler);
386     }
387 
388     @Override
389     public void withMVCGroup(@Nonnull String mvcType, @Nonnull MVCGroupFunction handler) {
390         application.getMvcGroupManager().withMVCGroup(mvcType, handler);
391     }
392 
393     @Override
394     public void withMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCGroupFunction handler) {
395         application.getMvcGroupManager().withMVCGroup(mvcType, mvcId, handler);
396     }
397 
398     @Override
399     public void withMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args, @Nonnull MVCGroupFunction handler) {
400         application.getMvcGroupManager().withMVCGroup(mvcType, mvcId, args, handler);
401     }
402 
403     @Override
404     public void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCGroupFunction handler) {
405         application.getMvcGroupManager().withMVCGroup(args, mvcType, mvcId, handler);
406     }
407 
408     @Override
409     public void withMVCGroup(@Nonnull String mvcType, @Nonnull Map<String, Object> args, @Nonnull MVCGroupFunction handler) {
410         application.getMvcGroupManager().withMVCGroup(mvcType, args, handler);
411     }
412 
413     @Override
414     public void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull MVCGroupFunction handler) {
415         application.getMvcGroupManager().withMVCGroup(args, mvcType, handler);
416     }
417 
418     @Override
419     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull TypedMVCGroupFunction<MVC> handler) {
420         application.getMvcGroupManager().withMVCGroup(mvcType, handler);
421     }
422 
423     @Override
424     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull TypedMVCGroupFunction<MVC> handler) {
425         application.getMvcGroupManager().withMVCGroup(mvcType, mvcId, handler);
426     }
427 
428     @Override
429     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args, @Nonnull TypedMVCGroupFunction<MVC> handler) {
430         application.getMvcGroupManager().withMVCGroup(mvcType, mvcId, args, handler);
431     }
432 
433     @Override
434     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull TypedMVCGroupFunction<MVC> handler) {
435         application.getMvcGroupManager().withMVCGroup(args, mvcType, mvcId, handler);
436     }
437 
438     @Override
439     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String, Object> args, @Nonnull TypedMVCGroupFunction<MVC> handler) {
440         application.getMvcGroupManager().withMVCGroup(mvcType, args, handler);
441     }
442 
443     @Override
444     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull TypedMVCGroupFunction<MVC> handler) {
445         application.getMvcGroupManager().withMVCGroup(args, mvcType, handler);
446     }
447 
448     /**
449      * Try to resolve the message.
450      *
451      @param key Key to lookup, such as 'log4j.appenders.console'
452      *
453      @return The resolved message at the given key for the default locale
454      *
455      @throws NoSuchMessageException if no message is found
456      @since 2.4.0
457      */
458     @Nonnull
459     protected String msg(@Nonnull String keythrows NoSuchMessageException {
460         return getApplication().getMessageSource().getMessage(key);
461     }
462 
463     /**
464      * Try to resolve the message.
465      *
466      @param key  Key to lookup, such as 'log4j.appenders.console'
467      @param args Arguments that will be filled in for params within the message (params look like "{0}" within a
468      *             message, but this might differ between implementations), or null if none.
469      *
470      @return The resolved message at the given key for the default locale
471      *
472      @throws NoSuchMessageException if no message is found
473      @since 2.4.0
474      */
475     @Nonnull
476     protected String msg(@Nonnull String key, @Nonnull List<?> argsthrows NoSuchMessageException {
477         return getApplication().getMessageSource().getMessage(key, args);
478     }
479 
480     /**
481      * Try to resolve the message.
482      *
483      @param key  Key to lookup, such as 'log4j.appenders.console'
484      @param args Arguments that will be filled in for params within the message (params look like "{0}" within a
485      *             message, but this might differ between implementations), or null if none.
486      *
487      @return The resolved message at the given key for the default locale
488      *
489      @throws NoSuchMessageException if no message is found
490      @since 2.4.0
491      */
492     @Nonnull
493     protected String msg(@Nonnull String key, @Nonnull Object[] argsthrows NoSuchMessageException {
494         return getApplication().getMessageSource().getMessage(key, args);
495     }
496 
497     /**
498      * Try to resolve the message.
499      *
500      @param key  Key to lookup, such as 'log4j.appenders.console'
501      @param args Arguments that will be filled in for params within the message (params look like "{:key}"
502      *             within a message, but this might differ between implementations), or null if none.
503      *
504      @return The resolved message at the given key for the default locale
505      *
506      @throws NoSuchMessageException if no message is found
507      @since 2.4.0
508      */
509     @Nonnull
510     protected String msg(@Nonnull String key, @Nonnull Map<String, Object> argsthrows NoSuchMessageException {
511         return getApplication().getMessageSource().getMessage(key, args);
512     }
513 }