DelegatingMVCGroup.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.mvc;
019 
020 import griffon.core.Context;
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.MVCGroupConfiguration;
028 import griffon.core.mvc.MVCGroupFunction;
029 import griffon.core.mvc.TypedMVCGroup;
030 import griffon.core.mvc.TypedMVCGroupFunction;
031 
032 import javax.annotation.Nonnull;
033 import javax.annotation.Nullable;
034 import java.util.List;
035 import java.util.Map;
036 
037 import static java.util.Objects.requireNonNull;
038 
039 /**
040  @author Andres Almiray
041  @since 2.11.0
042  */
043 public abstract class DelegatingMVCGroup implements MVCGroup {
044     private final MVCGroup delegate;
045 
046     public DelegatingMVCGroup(@Nonnull griffon.core.mvc.MVCGroup delegate) {
047         this.delegate = requireNonNull(delegate, "delegate");
048     }
049 
050     @Nonnull
051     public MVCGroup delegate() {
052         return delegate;
053     }
054 
055     @Override
056     @Nonnull
057     public MVCGroupConfiguration getConfiguration() {
058         return delegate.getConfiguration();
059     }
060 
061     @Override
062     @Nonnull
063     public String getMvcType() {
064         return delegate.getMvcType();
065     }
066 
067     @Override
068     @Nonnull
069     public String getMvcId() {
070         return delegate.getMvcId();
071     }
072 
073     @Override
074     @Nullable
075     public GriffonModel getModel() {
076         return delegate.getModel();
077     }
078 
079     @Override
080     @Nullable
081     public GriffonView getView() {
082         return delegate.getView();
083     }
084 
085     @Override
086     @Nullable
087     public GriffonController getController() {
088         return delegate.getController();
089     }
090 
091     @Override
092     @Nullable
093     public Object getMember(@Nonnull String name) {
094         return delegate.getMember(name);
095     }
096 
097     @Override
098     @Nonnull
099     public Map<String, Object> getMembers() {
100         return delegate.getMembers();
101     }
102 
103     @Override
104     public void destroy() {
105         delegate.destroy();
106     }
107 
108     @Override
109     public boolean isAlive() {
110         return delegate.isAlive();
111     }
112 
113     @Override
114     @Nonnull
115     public Context getContext() {
116         return delegate.getContext();
117     }
118 
119     @Override
120     @Nullable
121     public griffon.core.mvc.MVCGroup getParentGroup() {
122         return delegate.getParentGroup();
123     }
124 
125     @Override
126     @Nonnull
127     public Map<String, MVCGroup> getChildrenGroups() {
128         return delegate.getChildrenGroups();
129     }
130 
131     @Override
132     public void notifyMVCGroupDestroyed(@Nonnull String mvcId) {
133         delegate.notifyMVCGroupDestroyed(mvcId);
134     }
135 
136     @Override
137     @Nonnull
138     public MVCGroup createMVCGroup(@Nonnull String mvcType) {
139         return delegate.createMVCGroup(mvcType);
140     }
141 
142     @Override
143     @Nonnull
144     public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId) {
145         return delegate.createMVCGroup(mvcType, mvcId);
146     }
147 
148     @Override
149     @Nonnull
150     public MVCGroup createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType) {
151         return delegate.createMVCGroup(args, mvcType);
152     }
153 
154     @Override
155     @Nonnull
156     public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull Map<String, Object> args) {
157         return delegate.createMVCGroup(mvcType, args);
158     }
159 
160     @Override
161     @Nonnull
162     public MVCGroup createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId) {
163         return delegate.createMVCGroup(args, mvcType, mvcId);
164     }
165 
166     @Override
167     @Nonnull
168     public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
169         return delegate.createMVCGroup(mvcType, mvcId, args);
170     }
171 
172     @Override
173     @Nonnull
174     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType) {
175         return delegate.createMVCGroup(mvcType);
176     }
177 
178     @Override
179     @Nonnull
180     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
181         return delegate.createMVCGroup(mvcType, mvcId);
182     }
183 
184     @Override
185     @Nonnull
186     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType) {
187         return delegate.createMVCGroup(args, mvcType);
188     }
189 
190     @Override
191     @Nonnull
192     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String, Object> args) {
193         return delegate.createMVCGroup(mvcType, args);
194     }
195 
196     @Override
197     @Nonnull
198     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
199         return delegate.createMVCGroup(args, mvcType, mvcId);
200     }
201 
202     @Override
203     @Nonnull
204     public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
205         return delegate.createMVCGroup(mvcType, mvcId, args);
206     }
207 
208     @Override
209     @Nonnull
210     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType) {
211         return delegate.createMVC(mvcType);
212     }
213 
214     @Override
215     @Nonnull
216     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull String mvcType) {
217         return delegate.createMVC(args, mvcType);
218     }
219 
220     @Override
221     @Nonnull
222     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull Map<String, Object> args) {
223         return delegate.createMVC(mvcType, args);
224     }
225 
226     @Override
227     @Nonnull
228     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull String mvcId) {
229         return delegate.createMVC(mvcType, mvcId);
230     }
231 
232     @Override
233     @Nonnull
234     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId) {
235         return delegate.createMVC(args, mvcType, mvcId);
236     }
237 
238     @Override
239     @Nonnull
240     public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
241         return delegate.createMVC(mvcType, mvcId, args);
242     }
243 
244     @Override
245     @Nonnull
246     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType) {
247         return delegate.createMVC(mvcType);
248     }
249 
250     @Override
251     @Nonnull
252     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType) {
253         return delegate.createMVC(args, mvcType);
254     }
255 
256     @Override
257     @Nonnull
258     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String, Object> args) {
259         return delegate.createMVC(mvcType, args);
260     }
261 
262     @Override
263     @Nonnull
264     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
265         return delegate.createMVC(mvcType, mvcId);
266     }
267 
268     @Override
269     @Nonnull
270     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
271         return delegate.createMVC(args, mvcType, mvcId);
272     }
273 
274     @Override
275     @Nonnull
276     public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
277         return delegate.createMVC(mvcType, mvcId, args);
278     }
279 
280     @Override
281     public void destroyMVCGroup(@Nonnull String mvcId) {
282         delegate.destroyMVCGroup(mvcId);
283     }
284 
285     @Override
286     public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull MVCFunction<M, V, C> handler) {
287         delegate.withMVC(mvcType, handler);
288     }
289 
290     @Override
291     public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCFunction<M, V, C> handler) {
292         delegate.withMVC(mvcType, mvcId, handler);
293     }
294 
295     @Override
296     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) {
297         delegate.withMVC(mvcType, mvcId, args, handler);
298     }
299 
300     @Override
301     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) {
302         delegate.withMVC(args, mvcType, mvcId, handler);
303     }
304 
305     @Override
306     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) {
307         delegate.withMVC(mvcType, args, handler);
308     }
309 
310     @Override
311     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) {
312         delegate.withMVC(args, mvcType, handler);
313     }
314 
315     @Override
316     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) {
317         delegate.withMVC(mvcType, handler);
318     }
319 
320     @Override
321     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) {
322         delegate.withMVC(mvcType, mvcId, handler);
323     }
324 
325     @Override
326     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) {
327         delegate.withMVC(mvcType, mvcId, args, handler);
328     }
329 
330     @Override
331     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) {
332         delegate.withMVC(args, mvcType, mvcId, handler);
333     }
334 
335     @Override
336     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) {
337         delegate.withMVC(mvcType, args, handler);
338     }
339 
340     @Override
341     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) {
342         delegate.withMVC(args, mvcType, handler);
343     }
344 
345     @Override
346     public void withMVCGroup(@Nonnull String mvcType, @Nonnull MVCGroupFunction handler) {
347         delegate.withMVCGroup(mvcType, handler);
348     }
349 
350     @Override
351     public void withMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCGroupFunction handler) {
352         delegate.withMVCGroup(mvcType, mvcId, handler);
353     }
354 
355     @Override
356     public void withMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args, @Nonnull MVCGroupFunction handler) {
357         delegate.withMVCGroup(mvcType, mvcId, args, handler);
358     }
359 
360     @Override
361     public void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCGroupFunction handler) {
362         delegate.withMVCGroup(args, mvcType, mvcId, handler);
363     }
364 
365     @Override
366     public void withMVCGroup(@Nonnull String mvcType, @Nonnull Map<String, Object> args, @Nonnull MVCGroupFunction handler) {
367         delegate.withMVCGroup(mvcType, args, handler);
368     }
369 
370     @Override
371     public void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull MVCGroupFunction handler) {
372         delegate.withMVCGroup(args, mvcType, handler);
373     }
374 
375     @Override
376     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull TypedMVCGroupFunction<MVC> handler) {
377         delegate.withMVCGroup(mvcType, handler);
378     }
379 
380     @Override
381     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull TypedMVCGroupFunction<MVC> handler) {
382         delegate.withMVCGroup(mvcType, mvcId, handler);
383     }
384 
385     @Override
386     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args, @Nonnull TypedMVCGroupFunction<MVC> handler) {
387         delegate.withMVCGroup(mvcType, mvcId, args, handler);
388     }
389 
390     @Override
391     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull TypedMVCGroupFunction<MVC> handler) {
392         delegate.withMVCGroup(args, mvcType, mvcId, handler);
393     }
394 
395     @Override
396     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String, Object> args, @Nonnull TypedMVCGroupFunction<MVC> handler) {
397         delegate.withMVCGroup(mvcType, args, handler);
398     }
399 
400     @Override
401     public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull TypedMVCGroupFunction<MVC> handler) {
402         delegate.withMVCGroup(args, mvcType, handler);
403     }
404 }