EMMA Coverage Report (generated Wed Mar 28 02:10:09 CEST 2012)
[all classes][org.jomc.ri.model]

COVERAGE SUMMARY FOR SOURCE FILE [RuntimeInstance.java]

nameclass, %method, %block, %line, %
RuntimeInstance.java100% (1/1)54%  (7/13)53%  (318/602)50%  (78.8/159)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class RuntimeInstance100% (1/1)54%  (7/13)53%  (318/602)50%  (78.8/159)
RuntimeInstance (Instance): void 0%   (0/1)0%   (0/58)0%   (0/14)
clear (): void 0%   (0/1)0%   (0/8)0%   (0/3)
gc (): void 0%   (0/1)0%   (0/5)0%   (0/2)
gcOrClear (boolean, boolean): void 0%   (0/1)0%   (0/97)0%   (0/31)
getJavaFactoryMethod (ClassLoader): Method 0%   (0/1)0%   (0/69)0%   (0/17)
getJavaFactoryMethodName (): String 0%   (0/1)0%   (0/10)0%   (0/3)
isJavaClassAssignable (ClassLoader): boolean 100% (1/1)85%  (53/62)84%  (11.8/14)
getJavaClass (ClassLoader): Class 100% (1/1)89%  (55/62)88%  (15/17)
getJavaClasses (ClassLoader): Class [] 100% (1/1)90%  (62/69)88%  (15/17)
getJavaConstructor (ClassLoader): Constructor 100% (1/1)90%  (62/69)88%  (15/17)
getJavaProxyClass (ClassLoader): Class 100% (1/1)90%  (62/69)88%  (15/17)
<static initializer> 100% (1/1)100% (21/21)100% (5/5)
RuntimeInstance (): void 100% (1/1)100% (3/3)100% (2/2)

1// SECTION-START[License Header]
2// <editor-fold defaultstate="collapsed" desc=" Generated License ">
3/*
4 *   Java Object Management and Configuration
5 *   Copyright (C) Christian Schulte, 2011-313
6 *   All rights reserved.
7 *
8 *   Redistribution and use in source and binary forms, with or without
9 *   modification, are permitted provided that the following conditions
10 *   are met:
11 *
12 *     o Redistributions of source code must retain the above copyright
13 *       notice, this list of conditions and the following disclaimer.
14 *
15 *     o Redistributions in binary form must reproduce the above copyright
16 *       notice, this list of conditions and the following disclaimer in
17 *       the documentation and/or other materials provided with the
18 *       distribution.
19 *
20 *   THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
21 *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
22 *   AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
23 *   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
24 *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 *   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29 *   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 *
31 *   $JOMC: RuntimeInstance.java 4381 2012-03-04 19:29:29Z schulte2005 $
32 *
33 */
34// </editor-fold>
35// SECTION-END
36package org.jomc.ri.model;
37 
38import java.lang.ref.Reference;
39import java.lang.ref.WeakReference;
40import java.lang.reflect.Constructor;
41import java.lang.reflect.Method;
42import java.util.Map;
43import javax.xml.bind.annotation.XmlTransient;
44import org.jomc.model.Instance;
45import org.jomc.model.Specification;
46import org.jomc.util.WeakIdentityHashMap;
47import static org.jomc.ri.model.RuntimeModelObjects.BOOTSTRAP_CLASSLOADER_KEY;
48import static org.jomc.ri.model.RuntimeModelObjects.classesByClassLoaderAndNameCache;
49import static org.jomc.ri.model.RuntimeModelObjects.createMap;
50 
51// SECTION-START[Documentation]
52// <editor-fold defaultstate="collapsed" desc=" Generated Documentation ">
53/**
54 * Runtime {@code Instance}.
55 *
56 * <dl>
57 *   <dt><b>Identifier:</b></dt><dd>org.jomc.ri.model.RuntimeInstance</dd>
58 *   <dt><b>Name:</b></dt><dd>JOMC RI RuntimeInstance</dd>
59 *   <dt><b>Specifications:</b></dt>
60 *     <dd>org.jomc.ri.model.RuntimeModelObject @ 1.2</dd>
61 *   <dt><b>Abstract:</b></dt><dd>No</dd>
62 *   <dt><b>Final:</b></dt><dd>No</dd>
63 *   <dt><b>Stateless:</b></dt><dd>No</dd>
64 * </dl>
65 *
66 * @author <a href="mailto:schulte2005@users.sourceforge.net">Christian Schulte</a> 1.2
67 * @version 1.2
68 */
69// </editor-fold>
70// SECTION-END
71// SECTION-START[Annotations]
72// <editor-fold defaultstate="collapsed" desc=" Generated Annotations ">
73@javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.2.2", comments = "See http://jomc.sourceforge.net/jomc/1.2/jomc-tools-1.2.2" )
74// </editor-fold>
75// SECTION-END
76public class RuntimeInstance extends Instance implements RuntimeModelObject
77{
78    // SECTION-START[RuntimeInstance]
79 
80    /** Classes by class loader any instance cache. */
81    @XmlTransient
82    static final Map<ClassLoader, Map<String, Reference<Class<?>[]>>> classesByClassLoaderAndInstanceCache =
83        new WeakIdentityHashMap<ClassLoader, Map<String, Reference<Class<?>[]>>>();
84 
85    /** Constructors by class loader any instance cache. */
86    @XmlTransient
87    static final Map<ClassLoader, Map<String, Reference<Constructor<?>>>> constructorsByClassLoaderAndInstanceCache =
88        new WeakIdentityHashMap<ClassLoader, Map<String, Reference<Constructor<?>>>>();
89 
90    /** Methods by class loader any instance cache. */
91    @XmlTransient
92    static final Map<ClassLoader, Map<String, Reference<Method>>> methodsByClassLoaderAndInstanceCache =
93        new WeakIdentityHashMap<ClassLoader, Map<String, Reference<Method>>>();
94 
95    /** Assignable flags by class loader any instance cache. */
96    @XmlTransient
97    static final Map<ClassLoader, Map<String, Boolean>> assignableFlagsByClassLoaderAndInstanceCache =
98        new WeakIdentityHashMap<ClassLoader, Map<String, Boolean>>();
99 
100    /** Proxy classes by class loader any instance cache. */
101    @XmlTransient
102    static final Map<ClassLoader, Map<String, Reference<Class<?>>>> proxyClassesByClassLoaderAndInstanceCache =
103        new WeakIdentityHashMap<ClassLoader, Map<String, Reference<Class<?>>>>();
104 
105    /** Method name. */
106    @XmlTransient
107    private volatile String javaClassFactoryMethodName;
108 
109    /**
110     * Creates a new {@code RuntimeInstance} instance by deeply copying a given {@code Instance} instance.
111     *
112     * @param instance The instance to copy.
113     *
114     * @throws NullPointerException if {@code instance} is {@code null}.
115     */
116    public RuntimeInstance( final Instance instance )
117    {
118        super( instance );
119 
120        if ( this.getAuthors() != null )
121        {
122            this.setAuthors( RuntimeModelObjects.getInstance().copyOf( this.getAuthors() ) );
123        }
124        if ( this.getDependencies() != null )
125        {
126            this.setDependencies( RuntimeModelObjects.getInstance().copyOf( this.getDependencies() ) );
127        }
128        if ( this.getDocumentation() != null )
129        {
130            this.setDocumentation( RuntimeModelObjects.getInstance().copyOf( this.getDocumentation() ) );
131        }
132        if ( this.getMessages() != null )
133        {
134            this.setMessages( RuntimeModelObjects.getInstance().copyOf( this.getMessages() ) );
135        }
136        if ( this.getProperties() != null )
137        {
138            this.setProperties( RuntimeModelObjects.getInstance().copyOf( this.getProperties() ) );
139        }
140        if ( this.getSpecifications() != null )
141        {
142            this.setSpecifications( RuntimeModelObjects.getInstance().copyOf( this.getSpecifications() ) );
143        }
144    }
145 
146    /**
147     * Gets the Java class of the instance for a given class loader.
148     * <p>This method queries an internal cache for a result object to return for the given argument values. If no
149     * cached result object is available, this method queries the super-class for a result object to return and caches
150     * the outcome of that query for use on successive calls.</p>
151     * <p><b>Note:</b><br/>Method {@code RuntimeModelObjects.clear()} must be used to synchronize the state of the
152     * internal cache with the state of the class loader, should the state of the class loader change.</p>
153     *
154     * @param classLoader The class loader to get the Java class from or {@code null}, to get the Java class from the
155     * platform's bootstrap class loader.
156     *
157     * @return The Java class of the instance.
158     *
159     * @throws ClassNotFoundException if the Java class is not found.
160     *
161     * @see #getClazz()
162     * @see RuntimeModelObjects#clear()
163     */
164    @Override
165    public Class<?> getJavaClass( final ClassLoader classLoader ) throws ClassNotFoundException
166    {
167        ClassLoader classLoaderKey = classLoader;
168        if ( classLoaderKey == null )
169        {
170            classLoaderKey = BOOTSTRAP_CLASSLOADER_KEY;
171        }
172 
173        synchronized ( classesByClassLoaderAndNameCache )
174        {
175            Class<?> javaClass = null;
176            Map<String, Reference<Class<?>>> map = classesByClassLoaderAndNameCache.get( classLoaderKey );
177 
178            if ( map == null )
179            {
180                map = createMap();
181                classesByClassLoaderAndNameCache.put( classLoaderKey, map );
182            }
183 
184            final Reference<Class<?>> reference = map.get( this.getClazz() );
185 
186            if ( reference != null )
187            {
188                javaClass = reference.get();
189            }
190 
191            if ( javaClass == null )
192            {
193                javaClass = super.getJavaClass( classLoader );
194                map.put( this.getClazz(), new WeakReference<Class<?>>( javaClass ) );
195            }
196 
197            return javaClass;
198        }
199    }
200 
201    /**
202     * Gets the Java classes of all specifications of the instance for a given class loader.
203     * <p>This method queries an internal cache for a result object to return for the given argument values. If no
204     * cached result object is available, this method queries the super-class for a result object to return and caches
205     * the outcome of that query for use on successive calls.</p>
206     * <p><b>Note:</b><br/>Method {@code RuntimeModelObjects.clear()} must be used to synchronize the state of the
207     * internal cache with the state of the instance and class loader, should the state of the instance or class loader
208     * change.</p>
209     *
210     * @param classLoader The class loader to get the Java classes from or {@code null}, to get the Java classes from
211     * the platform's bootstrap class loader.
212     *
213     * @return The Java classes of all specifications of the instance.
214     *
215     * @throws ClassNotFoundException if a Java class is not found.
216     *
217     * @see #getSpecifications()
218     * @see Specification#getClazz()
219     * @see RuntimeModelObjects#clear()
220     */
221    @Override
222    public Class<?>[] getJavaClasses( final ClassLoader classLoader ) throws ClassNotFoundException
223    {
224        ClassLoader classLoaderKey = classLoader;
225        if ( classLoaderKey == null )
226        {
227            classLoaderKey = BOOTSTRAP_CLASSLOADER_KEY;
228        }
229 
230        synchronized ( classesByClassLoaderAndInstanceCache )
231        {
232            Class<?>[] javaClasses = null;
233            Map<String, Reference<Class<?>[]>> map = classesByClassLoaderAndInstanceCache.get( classLoaderKey );
234 
235            if ( map == null )
236            {
237                map = createMap();
238                classesByClassLoaderAndInstanceCache.put( classLoaderKey, map );
239            }
240 
241            final Reference<Class<?>[]> reference = map.get( this.getIdentifier() );
242 
243            if ( reference != null )
244            {
245                javaClasses = reference.get();
246            }
247 
248            if ( javaClasses == null && ( reference != null || !map.containsKey( this.getIdentifier() ) ) )
249            {
250                javaClasses = super.getJavaClasses( classLoader );
251                map.put( this.getIdentifier(), new WeakReference<Class<?>[]>( javaClasses ) );
252            }
253 
254            return javaClasses;
255        }
256    }
257 
258    /**
259     * Gets the Java constructor to use for creating objects of the instance.
260     * <p>This method queries an internal cache for a result object to return for the given argument values. If no
261     * cached result object is available, this method queries the super-class for a result object to return and caches
262     * the outcome of that query for use on successive calls.</p>
263     * <p><b>Note:</b><br/>Method {@code RuntimeModelObjects.clear()} must be used to synchronize the state of the
264     * internal cache with the state of the instance and class loader, should the state of the instance or class loader
265     * change.</p>
266     *
267     * @param classLoader The class loader to get the Java class from or {@code null}, to get the Java class from the
268     * platform's bootstrap class loader.
269     *
270     * @return The public default Java constructor of the Java class of the instance or {@code null}, if that class
271     * does not declare such a constructor, is abstract or is not public.
272     *
273     * @throws ClassNotFoundException if the Java class is not found.
274     *
275     * @see #getJavaClass(java.lang.ClassLoader)
276     * @see RuntimeModelObjects#clear()
277     */
278    @Override
279    public Constructor<?> getJavaConstructor( final ClassLoader classLoader ) throws ClassNotFoundException
280    {
281        ClassLoader classLoaderKey = classLoader;
282        if ( classLoaderKey == null )
283        {
284            classLoaderKey = BOOTSTRAP_CLASSLOADER_KEY;
285        }
286 
287        synchronized ( constructorsByClassLoaderAndInstanceCache )
288        {
289            Constructor<?> javaClassConstructor = null;
290            Map<String, Reference<Constructor<?>>> map = constructorsByClassLoaderAndInstanceCache.get( classLoaderKey );
291 
292            if ( map == null )
293            {
294                map = createMap();
295                constructorsByClassLoaderAndInstanceCache.put( classLoaderKey, map );
296            }
297 
298            final Reference<Constructor<?>> reference = map.get( this.getIdentifier() );
299 
300            if ( reference != null )
301            {
302                javaClassConstructor = reference.get();
303            }
304 
305            if ( javaClassConstructor == null && ( reference != null || !map.containsKey( this.getIdentifier() ) ) )
306            {
307                javaClassConstructor = super.getJavaConstructor( classLoader );
308                map.put( this.getIdentifier(), new WeakReference<Constructor<?>>( javaClassConstructor ) );
309            }
310 
311            return javaClassConstructor;
312        }
313    }
314 
315    /**
316     * Gets the name of the Java method to use for creating objects of the instance.
317     * <p>This method queries an internal cache for a result object to return. If no cached result object is available,
318     * this method queries the super-class for a result object to return and caches the outcome of that query for use on
319     * successive calls.</p>
320     * <p><b>Note:</b><br/>Method {@code clear()} must be used to synchronize the state of the internal cache with the
321     * state of the instance, should the state of the instance change.</p>
322     *
323     * @return The name of the Java method to use for creating objects of the instance or {@code null}, if no such
324     * method name is supported.
325     *
326     * @see #getName()
327     * @see #clear()
328     */
329    @Override
330    public String getJavaFactoryMethodName()
331    {
332        if ( this.javaClassFactoryMethodName == null )
333        {
334            this.javaClassFactoryMethodName = super.getJavaFactoryMethodName();
335        }
336 
337        return this.javaClassFactoryMethodName;
338    }
339 
340    /**
341     * Gets the Java method to use for creating objects of the instance.
342     * <p>This method queries an internal cache for a result object to return for the given argument values. If no
343     * cached result object is available, this method queries the super-class for a result object to return and caches
344     * the outcome of that query for use on successive calls.</p>
345     * <p><b>Note:</b><br/>Method {@code RuntimeModelObjects.clear()} must be used to synchronize the state of the
346     * internal cache with the state of the instance and class loader, should the state of the instance or class loader
347     * change.</p>
348     *
349     * @param classLoader The class loader to get the Java class from or {@code null}, to get the Java class from the
350     * platform's bootstrap class loader.
351     *
352     * @return The public Java method of the Java class of the instance to use for creating objects of the instance or
353     * {@code null}, if that class does not declare such a method.
354     *
355     * @throws ClassNotFoundException if the Java class is not found.
356     *
357     * @see #getJavaClass(java.lang.ClassLoader)
358     * @see #getJavaFactoryMethodName()
359     * @see RuntimeModelObjects#clear()
360     */
361    @Override
362    public Method getJavaFactoryMethod( final ClassLoader classLoader ) throws ClassNotFoundException
363    {
364        ClassLoader classLoaderKey = classLoader;
365        if ( classLoaderKey == null )
366        {
367            classLoaderKey = BOOTSTRAP_CLASSLOADER_KEY;
368        }
369 
370        synchronized ( methodsByClassLoaderAndInstanceCache )
371        {
372            Method javaClassFactoryMethod = null;
373            Map<String, Reference<Method>> map = methodsByClassLoaderAndInstanceCache.get( classLoaderKey );
374 
375            if ( map == null )
376            {
377                map = createMap();
378                methodsByClassLoaderAndInstanceCache.put( classLoaderKey, map );
379            }
380 
381            final Reference<Method> reference = map.get( this.getIdentifier() );
382 
383            if ( reference != null )
384            {
385                javaClassFactoryMethod = reference.get();
386            }
387 
388            if ( javaClassFactoryMethod == null && ( reference != null || !map.containsKey( this.getIdentifier() ) ) )
389            {
390                javaClassFactoryMethod = super.getJavaFactoryMethod( classLoader );
391                map.put( this.getIdentifier(), new WeakReference<Method>( javaClassFactoryMethod ) );
392            }
393 
394            return javaClassFactoryMethod;
395        }
396    }
397 
398    /**
399     * Gets a flag indicating the Java class of the instance is assignable to all Java classes of all specifications of
400     * the instance.
401     * <p>This method queries an internal cache for a result object to return for the given argument values. If no
402     * cached result object is available, this method queries the super-class for a result object to return and caches
403     * the outcome of that query for use on successive calls.</p>
404     * <p><b>Note:</b><br/>Method {@code RuntimeModelObjects.clear()} must be used to synchronize the state of the
405     * internal cache with the state of the instance and class loader, should the state of the instance or class loader
406     * change.</p>
407     *
408     * @param classLoader The class loader to get the Java classes from or {@code null}, to get the Java classes from
409     * the platform's bootstrap class loader.
410     *
411     * @return {@code true}, if the Java class of the instance is assignable to all Java classes of all specifications
412     * of the instance; {@code false}, if the Java class of the instance is not assignable to all Java classes of all
413     * specifications of the instance.
414     *
415     * @throws ClassNotFoundException if a Java class is not found.
416     *
417     * @see #getJavaClass(java.lang.ClassLoader)
418     * @see #getJavaClasses(java.lang.ClassLoader)
419     * @see RuntimeModelObjects#clear()
420     */
421    @Override
422    public boolean isJavaClassAssignable( final ClassLoader classLoader ) throws ClassNotFoundException
423    {
424        ClassLoader classLoaderKey = classLoader;
425        if ( classLoaderKey == null )
426        {
427            classLoaderKey = BOOTSTRAP_CLASSLOADER_KEY;
428        }
429 
430        synchronized ( assignableFlagsByClassLoaderAndInstanceCache )
431        {
432            Map<String, Boolean> map = assignableFlagsByClassLoaderAndInstanceCache.get( classLoaderKey );
433 
434            if ( map == null )
435            {
436                map = createMap();
437                assignableFlagsByClassLoaderAndInstanceCache.put( classLoaderKey, map );
438            }
439 
440            Boolean javaClassAssignable = map.get( this.getIdentifier() );
441 
442            if ( javaClassAssignable == null && !map.containsKey( this.getIdentifier() ) )
443            {
444                javaClassAssignable = super.isJavaClassAssignable( classLoader );
445                map.put( this.getIdentifier(), javaClassAssignable );
446            }
447 
448            return javaClassAssignable == null ? false : javaClassAssignable;
449        }
450    }
451 
452    /**
453     * Gets the Java proxy class for a given class loader.
454     * <p>This method queries an internal cache for a result object to return for the given argument values. If no
455     * cached result object is available, this method queries the super-class for a result object to return and caches
456     * the outcome of that query for use on successive calls.</p>
457     * <p><b>Note:</b><br/>Method {@code RuntimeModelObjects.clear()} must be used to synchronize the state of the
458     * internal cache with the state of the instance and class loader, should the state of the instance or class loader
459     * change.</p>
460     *
461     * @param classLoader The class loader to get the Java proxy class for.
462     *
463     * @return The Java proxy class for {@code classLoader} or {@code null}, if the instance does not support a Java
464     * proxy class.
465     *
466     * @throws ClassNotFoundException if a Java class is not found.
467     *
468     * @see #getJavaClasses(java.lang.ClassLoader)
469     * @see RuntimeModelObjects#clear()
470     */
471    @Override
472    public Class<?> getJavaProxyClass( final ClassLoader classLoader ) throws ClassNotFoundException
473    {
474        ClassLoader classLoaderKey = classLoader;
475        if ( classLoaderKey == null )
476        {
477            classLoaderKey = BOOTSTRAP_CLASSLOADER_KEY;
478        }
479 
480        synchronized ( proxyClassesByClassLoaderAndInstanceCache )
481        {
482            Class<?> javaProxyClass = null;
483            Map<String, Reference<Class<?>>> map = proxyClassesByClassLoaderAndInstanceCache.get( classLoaderKey );
484 
485            if ( map == null )
486            {
487                map = createMap();
488                proxyClassesByClassLoaderAndInstanceCache.put( classLoaderKey, map );
489            }
490 
491            final Reference<Class<?>> reference = map.get( this.getIdentifier() );
492 
493            if ( reference != null )
494            {
495                javaProxyClass = reference.get();
496            }
497 
498            if ( javaProxyClass == null && ( reference != null || !map.containsKey( this.getIdentifier() ) ) )
499            {
500                javaProxyClass = super.getJavaProxyClass( classLoader );
501                map.put( this.getIdentifier(), new WeakReference<Class<?>>( javaProxyClass ) );
502            }
503 
504            return javaProxyClass;
505        }
506    }
507 
508    // SECTION-END
509    // SECTION-START[RuntimeModelObject]
510    public void gc()
511    {
512        this.gcOrClear( true, false );
513    }
514 
515    public void clear()
516    {
517        this.javaClassFactoryMethodName = null;
518        this.gcOrClear( false, true );
519    }
520 
521    private void gcOrClear( final boolean gc, final boolean clear )
522    {
523        if ( this.getAuthors() instanceof RuntimeModelObject )
524        {
525            if ( gc )
526            {
527                ( (RuntimeModelObject) this.getAuthors() ).gc();
528            }
529            if ( clear )
530            {
531                ( (RuntimeModelObject) this.getAuthors() ).clear();
532            }
533        }
534        if ( this.getDependencies() instanceof RuntimeModelObject )
535        {
536            if ( gc )
537            {
538                ( (RuntimeModelObject) this.getDependencies() ).gc();
539            }
540            if ( clear )
541            {
542                ( (RuntimeModelObject) this.getDependencies() ).clear();
543            }
544        }
545        if ( this.getDocumentation() instanceof RuntimeModelObject )
546        {
547            if ( gc )
548            {
549                ( (RuntimeModelObject) this.getDocumentation() ).gc();
550            }
551            if ( clear )
552            {
553                ( (RuntimeModelObject) this.getDocumentation() ).clear();
554            }
555        }
556        if ( this.getMessages() instanceof RuntimeModelObject )
557        {
558            if ( gc )
559            {
560                ( (RuntimeModelObject) this.getMessages() ).gc();
561            }
562            if ( clear )
563            {
564                ( (RuntimeModelObject) this.getMessages() ).clear();
565            }
566        }
567        if ( this.getProperties() instanceof RuntimeModelObject )
568        {
569            if ( gc )
570            {
571                ( (RuntimeModelObject) this.getProperties() ).gc();
572            }
573            if ( clear )
574            {
575                ( (RuntimeModelObject) this.getProperties() ).clear();
576            }
577        }
578        if ( this.getSpecifications() instanceof RuntimeModelObject )
579        {
580            if ( gc )
581            {
582                ( (RuntimeModelObject) this.getSpecifications() ).gc();
583            }
584            if ( clear )
585            {
586                ( (RuntimeModelObject) this.getSpecifications() ).clear();
587            }
588        }
589    }
590 
591    // SECTION-END
592    // SECTION-START[Constructors]
593    // <editor-fold defaultstate="collapsed" desc=" Generated Constructors ">
594    /** Creates a new {@code RuntimeInstance} instance. */
595    @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.2.2", comments = "See http://jomc.sourceforge.net/jomc/1.2/jomc-tools-1.2.2" )
596    public RuntimeInstance()
597    {
598        // SECTION-START[Default Constructor]
599        super();
600        // SECTION-END
601    }
602    // </editor-fold>
603    // SECTION-END
604    // SECTION-START[Dependencies]
605    // SECTION-END
606    // SECTION-START[Properties]
607    // SECTION-END
608    // SECTION-START[Messages]
609    // SECTION-END
610}

[all classes][org.jomc.ri.model]
EMMA 2.1.5320 (stable) (C) Vladimir Roubtsov