AbstractGriffonArtifact.java
001 /*
002  * Copyright 2008-2015 the original author or authors.
003  *
004  * Licensed under the Apache License, Version 2.0 (the "License");
005  * you may not use this file except in compliance with the License.
006  * You may obtain a copy of the License at
007  *
008  *     http://www.apache.org/licenses/LICENSE-2.0
009  *
010  * Unless required by applicable law or agreed to in writing, software
011  * distributed under the License is distributed on an "AS IS" BASIS,
012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013  * See the License for the specific language governing permissions and
014  * limitations under the License.
015  */
016 package org.codehaus.griffon.runtime.core.artifact;
017 
018 import griffon.core.GriffonApplication;
019 import griffon.core.artifact.GriffonArtifact;
020 import griffon.core.artifact.GriffonClass;
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 org.slf4j.Logger;
029 import org.slf4j.LoggerFactory;
030 
031 import javax.annotation.Nonnull;
032 import javax.annotation.Nullable;
033 import javax.annotation.concurrent.GuardedBy;
034 import javax.inject.Inject;
035 import java.io.InputStream;
036 import java.net.URL;
037 import java.util.List;
038 import java.util.Map;
039 import java.util.concurrent.Callable;
040 import java.util.concurrent.ExecutorService;
041 import java.util.concurrent.Future;
042 
043 /**
044  * Base implementation of the GriffonArtifact interface.
045  *
046  @author Andres Almiray
047  @since 2.0.0
048  */
049 public abstract class AbstractGriffonArtifact implements GriffonArtifact {
050     private final Logger log;
051     private final Object lock = new Object[0];
052     @Inject
053     protected GriffonApplication application;
054     @GuardedBy("lock")
055     private GriffonClass griffonClass;
056 
057     public AbstractGriffonArtifact() {
058         log = LoggerFactory.getLogger("griffon.app." + getArtifactType() "." + getClass().getName());
059     }
060 
061     /**
062      * Creates a new instance of this class.
063      *
064      @param application the GriffonApplication that holds this artifact.
065      @deprecated Griffon prefers field injection over constructor injector for artifacts as of 2.1.0
066      */
067     @Inject
068     @Deprecated
069     public AbstractGriffonArtifact(@Nonnull GriffonApplication application) {
070         this();
071         this.application = application;
072     }
073 
074     @Nonnull
075     public GriffonApplication getApplication() {
076         return application;
077     }
078 
079     @Nonnull
080     @Override
081     @SuppressWarnings("ConstantConditions")
082     public GriffonClass getGriffonClass() {
083         synchronized (lock) {
084             if (griffonClass == null) {
085                 griffonClass = application.getArtifactManager().findGriffonClass(getClass());
086             }
087             return griffonClass;
088         }
089     }
090 
091     @Nonnull
092     @Override
093     public Logger getLog() {
094         return log;
095     }
096 
097     @Nonnull
098     protected abstract String getArtifactType();
099 
100     @Override
101     public boolean isUIThread() {
102         return application.getUIThreadManager().isUIThread();
103     }
104 
105     @Nonnull
106     @Override
107     public <R> Future<R> runFuture(@Nonnull ExecutorService executorService, @Nonnull Callable<R> callable) {
108         return application.getUIThreadManager().runFuture(executorService, callable);
109     }
110 
111     @Nonnull
112     @Override
113     public <R> Future<R> runFuture(@Nonnull Callable<R> callable) {
114         return application.getUIThreadManager().runFuture(callable);
115     }
116 
117     @Override
118     public void runInsideUISync(@Nonnull Runnable runnable) {
119         application.getUIThreadManager().runInsideUISync(runnable);
120     }
121 
122     @Override
123     public void runOutsideUI(@Nonnull Runnable runnable) {
124         application.getUIThreadManager().runOutsideUI(runnable);
125     }
126 
127     @Override
128     public void runInsideUIAsync(@Nonnull Runnable runnable) {
129         application.getUIThreadManager().runInsideUIAsync(runnable);
130     }
131 
132     @Nullable
133     @Override
134     public <R> R runInsideUISync(@Nonnull Callable<R> callable) {
135         return application.getUIThreadManager().runInsideUISync(callable);
136     }
137 
138     @Nonnull
139     @Override
140     public ClassLoader classloader() {
141         return application.getResourceHandler().classloader();
142     }
143 
144     @Nullable
145     @Override
146     public URL getResourceAsURL(@Nonnull String name) {
147         return application.getResourceHandler().getResourceAsURL(name);
148     }
149 
150     @Nullable
151     @Override
152     public List<URL> getResources(@Nonnull String name) {
153         return application.getResourceHandler().getResources(name);
154     }
155 
156     @Nullable
157     @Override
158     public InputStream getResourceAsStream(@Nonnull String name) {
159         return application.getResourceHandler().getResourceAsStream(name);
160     }
161 
162     @Nonnull
163     @Override
164     public MVCGroup createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType) {
165         return application.getMvcGroupManager().createMVCGroup(args, mvcType);
166     }
167 
168     @Nonnull
169     @Override
170     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType) {
171         return application.getMvcGroupManager().createMVC(mvcType);
172     }
173 
174     @Override
175     public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCFunction<M, V, C> handler) {
176         application.getMvcGroupManager().withMVC(mvcType, mvcId, handler);
177     }
178 
179     @Nonnull
180     @Override
181     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull String mvcId) {
182         return application.getMvcGroupManager().createMVC(mvcType, mvcId);
183     }
184 
185     @Nonnull
186     @Override
187     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId) {
188         return application.getMvcGroupManager().createMVC(args, mvcType, mvcId);
189     }
190 
191     @Override
192     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) {
193         application.getMvcGroupManager().withMVC(args, mvcType, mvcId, handler);
194     }
195 
196     @Nonnull
197     @Override
198     public MVCGroup createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId) {
199         return application.getMvcGroupManager().createMVCGroup(args, mvcType, mvcId);
200     }
201 
202     @Nonnull
203     @Override
204     public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
205         return application.getMvcGroupManager().createMVCGroup(mvcType, mvcId, args);
206     }
207 
208     @Nonnull
209     @Override
210     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull String mvcType) {
211         return application.getMvcGroupManager().createMVC(args, mvcType);
212     }
213 
214     @Override
215     public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull MVCFunction<M, V, C> handler) {
216         application.getMvcGroupManager().withMVC(mvcType, handler);
217     }
218 
219     @Nonnull
220     @Override
221     public MVCGroup createMVCGroup(@Nonnull String mvcType) {
222         return application.getMvcGroupManager().createMVCGroup(mvcType);
223     }
224 
225     @Nonnull
226     @Override
227     public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId) {
228         return application.getMvcGroupManager().createMVCGroup(mvcType, mvcId);
229     }
230 
231     @Nonnull
232     @Override
233     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull Map<String, Object> args) {
234         return application.getMvcGroupManager().createMVC(mvcType, args);
235     }
236 
237     @Override
238     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) {
239         application.getMvcGroupManager().withMVC(args, mvcType, handler);
240     }
241 
242     @Override
243     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) {
244         application.getMvcGroupManager().withMVC(mvcType, args, handler);
245     }
246 
247     @Nonnull
248     @Override
249     public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull Map<String, Object> args) {
250         return application.getMvcGroupManager().createMVCGroup(mvcType, args);
251     }
252 
253     @Nonnull
254     @Override
255     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
256         return application.getMvcGroupManager().createMVC(mvcType, mvcId, args);
257     }
258 
259     @Override
260     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) {
261         application.getMvcGroupManager().withMVC(mvcType, mvcId, args, handler);
262     }
263 
264     @Override
265     public void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull MVCGroupFunction handler) {
266         application.getMvcGroupManager().withMVCGroup(args, mvcType, handler);
267     }
268 
269     @Override
270     public void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCGroupFunction handler) {
271         application.getMvcGroupManager().withMVCGroup(args, mvcType, mvcId, handler);
272     }
273 
274     @Override
275     public void withMVCGroup(@Nonnull String mvcType, @Nonnull Map<String, Object> args, @Nonnull MVCGroupFunction handler) {
276         application.getMvcGroupManager().withMVCGroup(mvcType, args, handler);
277     }
278 
279     @Override
280     public void withMVCGroup(@Nonnull String mvcType, @Nonnull MVCGroupFunction handler) {
281         application.getMvcGroupManager().withMVCGroup(mvcType, handler);
282     }
283 
284     @Override
285     public void withMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args, @Nonnull MVCGroupFunction handler) {
286         application.getMvcGroupManager().withMVCGroup(mvcType, mvcId, args, handler);
287     }
288 
289     @Override
290     public void withMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCGroupFunction handler) {
291         application.getMvcGroupManager().withMVCGroup(mvcType, mvcId, handler);
292     }
293 
294     @Override
295     public void destroyMVCGroup(@Nonnull String mvcId) {
296         application.getMvcGroupManager().destroyMVCGroup(mvcId);
297     }
298 }