001// SECTION-START[License Header] 002// <editor-fold defaultstate="collapsed" desc=" Generated License "> 003/* 004 * Java Object Management and Configuration 005 * Copyright (C) Christian Schulte, 2011-313 006 * All rights reserved. 007 * 008 * Redistribution and use in source and binary forms, with or without 009 * modification, are permitted provided that the following conditions 010 * are met: 011 * 012 * o Redistributions of source code must retain the above copyright 013 * notice, this list of conditions and the following disclaimer. 014 * 015 * o Redistributions in binary form must reproduce the above copyright 016 * notice, this list of conditions and the following disclaimer in 017 * the documentation and/or other materials provided with the 018 * distribution. 019 * 020 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 021 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 022 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 023 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT, 024 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 025 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 026 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 027 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 028 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 029 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 030 * 031 * $JOMC: RuntimeInstance.java 4712 2013-01-02 13:56:12Z schulte $ 032 * 033 */ 034// </editor-fold> 035// SECTION-END 036package org.jomc.ri.model; 037 038import java.lang.ref.Reference; 039import java.lang.ref.WeakReference; 040import java.lang.reflect.Constructor; 041import java.lang.reflect.Method; 042import java.util.Map; 043import javax.xml.bind.annotation.XmlTransient; 044import org.jomc.model.Instance; 045import org.jomc.model.JavaTypeName; 046import org.jomc.model.ModelObjectException; 047import org.jomc.model.Specification; 048import org.jomc.util.WeakIdentityHashMap; 049import static org.jomc.ri.model.RuntimeModelObjects.BOOTSTRAP_CLASSLOADER_KEY; 050import static org.jomc.ri.model.RuntimeModelObjects.classesByClassLoaderAndNameCache; 051import static org.jomc.ri.model.RuntimeModelObjects.createMap; 052 053// SECTION-START[Documentation] 054// <editor-fold defaultstate="collapsed" desc=" Generated Documentation "> 055/** 056 * Runtime {@code Instance}. 057 * 058 * <dl> 059 * <dt><b>Identifier:</b></dt><dd>org.jomc.ri.model.RuntimeInstance</dd> 060 * <dt><b>Name:</b></dt><dd>JOMC ⁑ RI ⁑ RuntimeInstance</dd> 061 * <dt><b>Specifications:</b></dt> 062 * <dd>org.jomc.ri.model.RuntimeModelObject @ 1.2</dd> 063 * <dt><b>Abstract:</b></dt><dd>No</dd> 064 * <dt><b>Final:</b></dt><dd>No</dd> 065 * <dt><b>Stateless:</b></dt><dd>No</dd> 066 * </dl> 067 * 068 * @author <a href="mailto:cs@schulte.it">Christian Schulte</a> 1.2 069 * @version 1.2 070 */ 071// </editor-fold> 072// SECTION-END 073// SECTION-START[Annotations] 074// <editor-fold defaultstate="collapsed" desc=" Generated Annotations "> 075@javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 076// </editor-fold> 077// SECTION-END 078public class RuntimeInstance extends Instance implements RuntimeModelObject 079{ 080 // SECTION-START[RuntimeInstance] 081 082 /** Classes by class loader any instance cache. */ 083 @XmlTransient 084 static final Map<ClassLoader, Map<String, Reference<Class<?>[]>>> classesByClassLoaderAndInstanceCache = 085 new WeakIdentityHashMap<ClassLoader, Map<String, Reference<Class<?>[]>>>(); 086 087 /** Constructors by class loader any instance cache. */ 088 @XmlTransient 089 static final Map<ClassLoader, Map<String, Reference<Constructor<?>>>> constructorsByClassLoaderAndInstanceCache = 090 new WeakIdentityHashMap<ClassLoader, Map<String, Reference<Constructor<?>>>>(); 091 092 /** Methods by class loader any instance cache. */ 093 @XmlTransient 094 static final Map<ClassLoader, Map<String, Reference<Method>>> methodsByClassLoaderAndInstanceCache = 095 new WeakIdentityHashMap<ClassLoader, Map<String, Reference<Method>>>(); 096 097 /** Assignable flags by class loader any instance cache. */ 098 @XmlTransient 099 static final Map<ClassLoader, Map<String, Boolean>> assignableFlagsByClassLoaderAndInstanceCache = 100 new WeakIdentityHashMap<ClassLoader, Map<String, Boolean>>(); 101 102 /** Proxy classes by class loader any instance cache. */ 103 @XmlTransient 104 static final Map<ClassLoader, Map<String, Reference<Class<?>>>> proxyClassesByClassLoaderAndInstanceCache = 105 new WeakIdentityHashMap<ClassLoader, Map<String, Reference<Class<?>>>>(); 106 107 /** Method name. */ 108 @XmlTransient 109 private volatile String javaClassFactoryMethodName; 110 111 /** Java type name. */ 112 @XmlTransient 113 private volatile JavaTypeName javaTypeName; 114 115 /** 116 * Creates a new {@code RuntimeInstance} instance by deeply copying a given {@code Instance} instance. 117 * 118 * @param instance The instance to copy. 119 * 120 * @throws NullPointerException if {@code instance} is {@code null}. 121 */ 122 public RuntimeInstance( final Instance instance ) 123 { 124 super( instance ); 125 126 if ( this.getAuthors() != null ) 127 { 128 this.setAuthors( RuntimeModelObjects.getInstance().copyOf( this.getAuthors() ) ); 129 } 130 if ( this.getDependencies() != null ) 131 { 132 this.setDependencies( RuntimeModelObjects.getInstance().copyOf( this.getDependencies() ) ); 133 } 134 if ( this.getDocumentation() != null ) 135 { 136 this.setDocumentation( RuntimeModelObjects.getInstance().copyOf( this.getDocumentation() ) ); 137 } 138 if ( this.getMessages() != null ) 139 { 140 this.setMessages( RuntimeModelObjects.getInstance().copyOf( this.getMessages() ) ); 141 } 142 if ( this.getProperties() != null ) 143 { 144 this.setProperties( RuntimeModelObjects.getInstance().copyOf( this.getProperties() ) ); 145 } 146 if ( this.getSpecifications() != null ) 147 { 148 this.setSpecifications( RuntimeModelObjects.getInstance().copyOf( this.getSpecifications() ) ); 149 } 150 } 151 152 /** 153 * Gets the Java class of the instance for a given class loader. 154 * <p>This method queries an internal cache for a result object to return for the given argument values. If no 155 * cached result object is available, this method queries the super-class for a result object to return and caches 156 * the outcome of that query for use on successive calls.</p> 157 * <p><b>Note:</b><br/>Method {@code RuntimeModelObjects.clear()} must be used to synchronize the state of the 158 * internal cache with the state of the class loader, should the state of the class loader change.</p> 159 * 160 * @param classLoader The class loader to get the Java class from or {@code null}, to get the Java class from the 161 * platform's bootstrap class loader. 162 * 163 * @return The Java class of the instance. 164 * 165 * @throws ClassNotFoundException if the Java class is not found. 166 * @throws ModelObjectException if parsing the name of the referenced type fails. 167 * 168 * @see #getClazz() 169 * @see RuntimeModelObjects#clear() 170 */ 171 @Override 172 public Class<?> getJavaClass( final ClassLoader classLoader ) 173 throws ModelObjectException, ClassNotFoundException 174 { 175 Class<?> javaClass = null; 176 177 if ( this.getJavaTypeName() != null ) 178 { 179 ClassLoader classLoaderKey = classLoader; 180 if ( classLoaderKey == null ) 181 { 182 classLoaderKey = BOOTSTRAP_CLASSLOADER_KEY; 183 } 184 185 synchronized ( classesByClassLoaderAndNameCache ) 186 { 187 Map<String, Reference<Class<?>>> map = classesByClassLoaderAndNameCache.get( classLoaderKey ); 188 189 if ( map == null ) 190 { 191 map = createMap(); 192 classesByClassLoaderAndNameCache.put( classLoaderKey, map ); 193 } 194 195 final Reference<Class<?>> reference = map.get( this.getJavaTypeName().getClassName() ); 196 197 if ( reference != null ) 198 { 199 javaClass = reference.get(); 200 } 201 202 if ( javaClass == null ) 203 { 204 javaClass = super.getJavaClass( classLoader ); 205 map.put( this.getJavaTypeName().getClassName(), new WeakReference<Class<?>>( javaClass ) ); 206 } 207 } 208 } 209 210 return javaClass; 211 } 212 213 /** 214 * Gets the Java classes of all specifications of the instance for a given class loader. 215 * <p>This method queries an internal cache for a result object to return for the given argument values. If no 216 * cached result object is available, this method queries the super-class for a result object to return and caches 217 * the outcome of that query for use on successive calls.</p> 218 * <p><b>Note:</b><br/>Method {@code RuntimeModelObjects.clear()} must be used to synchronize the state of the 219 * internal cache with the state of the instance and class loader, should the state of the instance or class loader 220 * change.</p> 221 * 222 * @param classLoader The class loader to get the Java classes from or {@code null}, to get the Java classes from 223 * the platform's bootstrap class loader. 224 * 225 * @return The Java classes of all specifications of the instance. 226 * 227 * @throws ClassNotFoundException if a Java class is not found. 228 * @throws ModelObjectException if parsing a name of a referenced type fails. 229 * 230 * @see #getSpecifications() 231 * @see Specification#getClazz() 232 * @see RuntimeModelObjects#clear() 233 */ 234 @Override 235 public Class<?>[] getJavaClasses( final ClassLoader classLoader ) 236 throws ModelObjectException, ClassNotFoundException 237 { 238 ClassLoader classLoaderKey = classLoader; 239 if ( classLoaderKey == null ) 240 { 241 classLoaderKey = BOOTSTRAP_CLASSLOADER_KEY; 242 } 243 244 synchronized ( classesByClassLoaderAndInstanceCache ) 245 { 246 Class<?>[] javaClasses = null; 247 Map<String, Reference<Class<?>[]>> map = classesByClassLoaderAndInstanceCache.get( classLoaderKey ); 248 249 if ( map == null ) 250 { 251 map = createMap(); 252 classesByClassLoaderAndInstanceCache.put( classLoaderKey, map ); 253 } 254 255 final Reference<Class<?>[]> reference = map.get( this.getIdentifier() ); 256 257 if ( reference != null ) 258 { 259 javaClasses = reference.get(); 260 } 261 262 if ( javaClasses == null && ( reference != null || !map.containsKey( this.getIdentifier() ) ) ) 263 { 264 javaClasses = super.getJavaClasses( classLoader ); 265 map.put( this.getIdentifier(), new WeakReference<Class<?>[]>( javaClasses ) ); 266 } 267 268 return javaClasses; 269 } 270 } 271 272 /** 273 * Gets the Java constructor to use for creating objects of the instance. 274 * <p>This method queries an internal cache for a result object to return for the given argument values. If no 275 * cached result object is available, this method queries the super-class for a result object to return and caches 276 * the outcome of that query for use on successive calls.</p> 277 * <p><b>Note:</b><br/>Method {@code RuntimeModelObjects.clear()} must be used to synchronize the state of the 278 * internal cache with the state of the instance and class loader, should the state of the instance or class loader 279 * change.</p> 280 * 281 * @param classLoader The class loader to get the Java class from or {@code null}, to get the Java class from the 282 * platform's bootstrap class loader. 283 * 284 * @return The public default Java constructor of the Java class of the instance or {@code null}, if that class 285 * does not declare such a constructor, is abstract or is not public. 286 * 287 * @throws ClassNotFoundException if the Java class is not found. 288 * @throws ModelObjectException if parsing the name of the type referenced by the instance fails. 289 * 290 * @see #getJavaClass(java.lang.ClassLoader) 291 * @see RuntimeModelObjects#clear() 292 */ 293 @Override 294 public Constructor<?> getJavaConstructor( final ClassLoader classLoader ) 295 throws ModelObjectException, ClassNotFoundException 296 { 297 ClassLoader classLoaderKey = classLoader; 298 if ( classLoaderKey == null ) 299 { 300 classLoaderKey = BOOTSTRAP_CLASSLOADER_KEY; 301 } 302 303 synchronized ( constructorsByClassLoaderAndInstanceCache ) 304 { 305 Constructor<?> javaClassConstructor = null; 306 Map<String, Reference<Constructor<?>>> map = constructorsByClassLoaderAndInstanceCache.get( classLoaderKey ); 307 308 if ( map == null ) 309 { 310 map = createMap(); 311 constructorsByClassLoaderAndInstanceCache.put( classLoaderKey, map ); 312 } 313 314 final Reference<Constructor<?>> reference = map.get( this.getIdentifier() ); 315 316 if ( reference != null ) 317 { 318 javaClassConstructor = reference.get(); 319 } 320 321 if ( javaClassConstructor == null && ( reference != null || !map.containsKey( this.getIdentifier() ) ) ) 322 { 323 javaClassConstructor = super.getJavaConstructor( classLoader ); 324 map.put( this.getIdentifier(), new WeakReference<Constructor<?>>( javaClassConstructor ) ); 325 } 326 327 return javaClassConstructor; 328 } 329 } 330 331 /** 332 * Gets the name of the Java method to use for creating objects of the instance. 333 * <p>This method queries an internal cache for a result object to return. If no cached result object is available, 334 * this method queries the super-class for a result object to return and caches the outcome of that query for use on 335 * successive calls.</p> 336 * <p><b>Note:</b><br/>Method {@code clear()} must be used to synchronize the state of the internal cache with the 337 * state of the instance, should the state of the instance change.</p> 338 * 339 * @return The name of the Java method to use for creating objects of the instance or {@code null}, if no such 340 * method name is supported. 341 * 342 * @throws ModelObjectException if compiling the name of the instance to a {@code JavaIdentifier} fails. 343 * 344 * @see #getName() 345 * @see #clear() 346 */ 347 @Override 348 public String getJavaFactoryMethodName() throws ModelObjectException 349 { 350 if ( this.javaClassFactoryMethodName == null ) 351 { 352 this.javaClassFactoryMethodName = super.getJavaFactoryMethodName(); 353 } 354 355 return this.javaClassFactoryMethodName; 356 } 357 358 /** 359 * Gets the Java method to use for creating objects of the instance. 360 * <p>This method queries an internal cache for a result object to return for the given argument values. If no 361 * cached result object is available, this method queries the super-class for a result object to return and caches 362 * the outcome of that query for use on successive calls.</p> 363 * <p><b>Note:</b><br/>Method {@code RuntimeModelObjects.clear()} must be used to synchronize the state of the 364 * internal cache with the state of the instance and class loader, should the state of the instance or class loader 365 * change.</p> 366 * 367 * @param classLoader The class loader to get the Java class from or {@code null}, to get the Java class from the 368 * platform's bootstrap class loader. 369 * 370 * @return The public Java method of the Java class of the instance to use for creating objects of the instance or 371 * {@code null}, if that class does not declare such a method. 372 * 373 * @throws ClassNotFoundException if the Java class is not found. 374 * @throws ModelObjectException if parsing the name of the type referenced by the instance fails. 375 * 376 * @see #getJavaClass(java.lang.ClassLoader) 377 * @see #getJavaFactoryMethodName() 378 * @see RuntimeModelObjects#clear() 379 */ 380 @Override 381 public Method getJavaFactoryMethod( final ClassLoader classLoader ) 382 throws ModelObjectException, ClassNotFoundException 383 { 384 ClassLoader classLoaderKey = classLoader; 385 if ( classLoaderKey == null ) 386 { 387 classLoaderKey = BOOTSTRAP_CLASSLOADER_KEY; 388 } 389 390 synchronized ( methodsByClassLoaderAndInstanceCache ) 391 { 392 Method javaClassFactoryMethod = null; 393 Map<String, Reference<Method>> map = methodsByClassLoaderAndInstanceCache.get( classLoaderKey ); 394 395 if ( map == null ) 396 { 397 map = createMap(); 398 methodsByClassLoaderAndInstanceCache.put( classLoaderKey, map ); 399 } 400 401 final Reference<Method> reference = map.get( this.getIdentifier() ); 402 403 if ( reference != null ) 404 { 405 javaClassFactoryMethod = reference.get(); 406 } 407 408 if ( javaClassFactoryMethod == null && ( reference != null || !map.containsKey( this.getIdentifier() ) ) ) 409 { 410 javaClassFactoryMethod = super.getJavaFactoryMethod( classLoader ); 411 map.put( this.getIdentifier(), new WeakReference<Method>( javaClassFactoryMethod ) ); 412 } 413 414 return javaClassFactoryMethod; 415 } 416 } 417 418 /** 419 * Gets a flag indicating the Java class of the instance is assignable to all Java classes of all specifications of 420 * the instance. 421 * <p>This method queries an internal cache for a result object to return for the given argument values. If no 422 * cached result object is available, this method queries the super-class for a result object to return and caches 423 * the outcome of that query for use on successive calls.</p> 424 * <p><b>Note:</b><br/>Method {@code RuntimeModelObjects.clear()} must be used to synchronize the state of the 425 * internal cache with the state of the instance and class loader, should the state of the instance or class loader 426 * change.</p> 427 * 428 * @param classLoader The class loader to get the Java classes from or {@code null}, to get the Java classes from 429 * the platform's bootstrap class loader. 430 * 431 * @return {@code true}, if the Java class of the instance is assignable to all Java classes of all specifications 432 * of the instance; {@code false}, if the Java class of the instance is not assignable to all Java classes of all 433 * specifications of the instance. 434 * 435 * @throws ClassNotFoundException if a Java class is not found. 436 * @throws ModelObjectException if parsing a name of a referenced type fails. 437 * 438 * @see #getJavaClass(java.lang.ClassLoader) 439 * @see #getJavaClasses(java.lang.ClassLoader) 440 * @see RuntimeModelObjects#clear() 441 */ 442 @Override 443 public boolean isJavaClassAssignable( final ClassLoader classLoader ) 444 throws ModelObjectException, ClassNotFoundException 445 { 446 ClassLoader classLoaderKey = classLoader; 447 if ( classLoaderKey == null ) 448 { 449 classLoaderKey = BOOTSTRAP_CLASSLOADER_KEY; 450 } 451 452 synchronized ( assignableFlagsByClassLoaderAndInstanceCache ) 453 { 454 Map<String, Boolean> map = assignableFlagsByClassLoaderAndInstanceCache.get( classLoaderKey ); 455 456 if ( map == null ) 457 { 458 map = createMap(); 459 assignableFlagsByClassLoaderAndInstanceCache.put( classLoaderKey, map ); 460 } 461 462 Boolean javaClassAssignable = map.get( this.getIdentifier() ); 463 464 if ( javaClassAssignable == null && !map.containsKey( this.getIdentifier() ) ) 465 { 466 javaClassAssignable = super.isJavaClassAssignable( classLoader ); 467 map.put( this.getIdentifier(), javaClassAssignable ); 468 } 469 470 return javaClassAssignable == null ? false : javaClassAssignable; 471 } 472 } 473 474 /** 475 * Gets the Java proxy class for a given class loader. 476 * <p>This method queries an internal cache for a result object to return for the given argument values. If no 477 * cached result object is available, this method queries the super-class for a result object to return and caches 478 * the outcome of that query for use on successive calls.</p> 479 * <p><b>Note:</b><br/>Method {@code RuntimeModelObjects.clear()} must be used to synchronize the state of the 480 * internal cache with the state of the instance and class loader, should the state of the instance or class loader 481 * change.</p> 482 * 483 * @param classLoader The class loader to get the Java proxy class for. 484 * 485 * @return The Java proxy class for {@code classLoader} or {@code null}, if the instance does not support a Java 486 * proxy class. 487 * 488 * @throws ClassNotFoundException if a Java class is not found. 489 * @throws ModelObjectException if parsing a name of a referenced type fails. 490 * 491 * @see #getJavaClasses(java.lang.ClassLoader) 492 * @see RuntimeModelObjects#clear() 493 */ 494 @Override 495 public Class<?> getJavaProxyClass( final ClassLoader classLoader ) 496 throws ModelObjectException, ClassNotFoundException 497 { 498 ClassLoader classLoaderKey = classLoader; 499 if ( classLoaderKey == null ) 500 { 501 classLoaderKey = BOOTSTRAP_CLASSLOADER_KEY; 502 } 503 504 synchronized ( proxyClassesByClassLoaderAndInstanceCache ) 505 { 506 Class<?> javaProxyClass = null; 507 Map<String, Reference<Class<?>>> map = proxyClassesByClassLoaderAndInstanceCache.get( classLoaderKey ); 508 509 if ( map == null ) 510 { 511 map = createMap(); 512 proxyClassesByClassLoaderAndInstanceCache.put( classLoaderKey, map ); 513 } 514 515 final Reference<Class<?>> reference = map.get( this.getIdentifier() ); 516 517 if ( reference != null ) 518 { 519 javaProxyClass = reference.get(); 520 } 521 522 if ( javaProxyClass == null && ( reference != null || !map.containsKey( this.getIdentifier() ) ) ) 523 { 524 javaProxyClass = super.getJavaProxyClass( classLoader ); 525 map.put( this.getIdentifier(), new WeakReference<Class<?>>( javaProxyClass ) ); 526 } 527 528 return javaProxyClass; 529 } 530 } 531 532 /** 533 * Gets the Java type name of the type referenced by the instance. 534 * <p>This method queries an internal cache for a result object to return. If no cached result object is available, 535 * this method queries the super-class for a result object to return and caches the outcome of that query for use on 536 * successive calls.</p> 537 * <p><b>Note:</b><br/>Method {@code clear()} must be used to synchronize the state of the internal cache with the 538 * state of the instance, should the state of the instance change.</p> 539 * 540 * @return The Java type name of the type referenced by the instance or {@code null}, if the instance does not 541 * reference a type. 542 * 543 * @throws ModelObjectException if compiling the name of the referenced type to a {@code JavaTypeName} fails. 544 * 545 * @since 1.4 546 * 547 * @see Instance#getJavaTypeName() 548 * @see #clear() 549 */ 550 @Override 551 public JavaTypeName getJavaTypeName() throws ModelObjectException 552 { 553 if ( this.javaTypeName == null ) 554 { 555 this.javaTypeName = super.getJavaTypeName(); 556 } 557 558 return this.javaTypeName; 559 } 560 561 // SECTION-END 562 // SECTION-START[RuntimeModelObject] 563 public void gc() 564 { 565 this.gcOrClear( true, false ); 566 } 567 568 public void clear() 569 { 570 this.javaClassFactoryMethodName = null; 571 this.javaTypeName = null; 572 this.gcOrClear( false, true ); 573 } 574 575 private void gcOrClear( final boolean gc, final boolean clear ) 576 { 577 if ( this.getAuthors() instanceof RuntimeModelObject ) 578 { 579 if ( gc ) 580 { 581 ( (RuntimeModelObject) this.getAuthors() ).gc(); 582 } 583 if ( clear ) 584 { 585 ( (RuntimeModelObject) this.getAuthors() ).clear(); 586 } 587 } 588 if ( this.getDependencies() instanceof RuntimeModelObject ) 589 { 590 if ( gc ) 591 { 592 ( (RuntimeModelObject) this.getDependencies() ).gc(); 593 } 594 if ( clear ) 595 { 596 ( (RuntimeModelObject) this.getDependencies() ).clear(); 597 } 598 } 599 if ( this.getDocumentation() instanceof RuntimeModelObject ) 600 { 601 if ( gc ) 602 { 603 ( (RuntimeModelObject) this.getDocumentation() ).gc(); 604 } 605 if ( clear ) 606 { 607 ( (RuntimeModelObject) this.getDocumentation() ).clear(); 608 } 609 } 610 if ( this.getMessages() instanceof RuntimeModelObject ) 611 { 612 if ( gc ) 613 { 614 ( (RuntimeModelObject) this.getMessages() ).gc(); 615 } 616 if ( clear ) 617 { 618 ( (RuntimeModelObject) this.getMessages() ).clear(); 619 } 620 } 621 if ( this.getProperties() instanceof RuntimeModelObject ) 622 { 623 if ( gc ) 624 { 625 ( (RuntimeModelObject) this.getProperties() ).gc(); 626 } 627 if ( clear ) 628 { 629 ( (RuntimeModelObject) this.getProperties() ).clear(); 630 } 631 } 632 if ( this.getSpecifications() instanceof RuntimeModelObject ) 633 { 634 if ( gc ) 635 { 636 ( (RuntimeModelObject) this.getSpecifications() ).gc(); 637 } 638 if ( clear ) 639 { 640 ( (RuntimeModelObject) this.getSpecifications() ).clear(); 641 } 642 } 643 } 644 645 // SECTION-END 646 // SECTION-START[Constructors] 647 // <editor-fold defaultstate="collapsed" desc=" Generated Constructors "> 648 /** Creates a new {@code RuntimeInstance} instance. */ 649 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 650 public RuntimeInstance() 651 { 652 // SECTION-START[Default Constructor] 653 super(); 654 // SECTION-END 655 } 656 // </editor-fold> 657 // SECTION-END 658 // SECTION-START[Dependencies] 659 // SECTION-END 660 // SECTION-START[Properties] 661 // SECTION-END 662 // SECTION-START[Messages] 663 // SECTION-END 664}