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, 2005-206 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: DefaultObjectManager.java 4712 2013-01-02 13:56:12Z schulte $ 032 * 033 */ 034// </editor-fold> 035// SECTION-END 036package org.jomc.ri; 037 038import java.io.IOException; 039import java.lang.ref.Reference; 040import java.lang.ref.WeakReference; 041import java.lang.reflect.Array; 042import java.lang.reflect.Constructor; 043import java.lang.reflect.InvocationHandler; 044import java.lang.reflect.InvocationTargetException; 045import java.lang.reflect.Method; 046import java.math.BigInteger; 047import java.net.URI; 048import java.text.MessageFormat; 049import java.util.ArrayList; 050import java.util.Collections; 051import java.util.HashMap; 052import java.util.LinkedList; 053import java.util.List; 054import java.util.Locale; 055import java.util.Map; 056import java.util.logging.Level; 057import java.util.logging.LogRecord; 058import org.jomc.ObjectManagementException; 059import org.jomc.ObjectManager; 060import org.jomc.ObjectManagerFactory; 061import org.jomc.model.Dependency; 062import org.jomc.model.Implementation; 063import org.jomc.model.ImplementationReference; 064import org.jomc.model.Implementations; 065import org.jomc.model.Instance; 066import org.jomc.model.Message; 067import org.jomc.model.ModelObject; 068import org.jomc.model.ModelObjectException; 069import org.jomc.model.Module; 070import org.jomc.model.Modules; 071import org.jomc.model.Multiplicity; 072import org.jomc.model.Property; 073import org.jomc.model.PropertyException; 074import org.jomc.model.Specification; 075import org.jomc.model.SpecificationReference; 076import org.jomc.model.Specifications; 077import org.jomc.model.modlet.ModelHelper; 078import org.jomc.modlet.Model; 079import org.jomc.modlet.ModelContext; 080import org.jomc.modlet.ModelContextFactory; 081import org.jomc.modlet.ModelException; 082import org.jomc.modlet.ModelValidationReport; 083import org.jomc.ri.model.RuntimeModelObject; 084import org.jomc.ri.model.RuntimeModules; 085import org.jomc.spi.Invocation; 086import org.jomc.spi.Invoker; 087import org.jomc.spi.Listener; 088import org.jomc.spi.Locator; 089import org.jomc.spi.Scope; 090import org.jomc.util.WeakIdentityHashMap; 091 092// SECTION-START[Documentation] 093// <editor-fold defaultstate="collapsed" desc=" Generated Documentation "> 094/** 095 * Default {@code ObjectManager} implementation. 096 * 097 * <dl> 098 * <dt><b>Identifier:</b></dt><dd>org.jomc.ri.DefaultObjectManager</dd> 099 * <dt><b>Name:</b></dt><dd>JOMC ⁑ RI ⁑ DefaultObjectManager</dd> 100 * <dt><b>Specifications:</b></dt> 101 * <dd>org.jomc.ObjectManager @ 1.0</dd> 102 * <dt><b>Abstract:</b></dt><dd>No</dd> 103 * <dt><b>Final:</b></dt><dd>No</dd> 104 * <dt><b>Stateless:</b></dt><dd>No</dd> 105 * </dl> 106 * 107 * @author <a href="mailto:cs@schulte.it">Christian Schulte</a> 1.0 108 * @version 1.2 109 */ 110// </editor-fold> 111// SECTION-END 112// SECTION-START[Annotations] 113// <editor-fold defaultstate="collapsed" desc=" Generated Annotations "> 114@javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 115// </editor-fold> 116// SECTION-END 117public class DefaultObjectManager implements ObjectManager 118{ 119 // SECTION-START[Constructors] 120 // <editor-fold defaultstate="collapsed" desc=" Generated Constructors "> 121 /** Creates a new {@code DefaultObjectManager} instance. */ 122 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 123 public DefaultObjectManager() 124 { 125 // SECTION-START[Default Constructor] 126 super(); 127 // SECTION-END 128 } 129 // </editor-fold> 130 // SECTION-END 131 // SECTION-START[ObjectManager] 132 133 public <T> T getObject( final Class<T> specification ) 134 { 135 if ( specification == null ) 136 { 137 throw new NullPointerException( "specification" ); 138 } 139 140 try 141 { 142 this.initialize(); 143 144 Class<?> specificationClass = specification; 145 if ( specification.isArray() ) 146 { 147 specificationClass = specification.getComponentType(); 148 } 149 150 final ClassLoader classLoader = this.getDefaultClassLoader( specificationClass ); 151 final Modules model = this.getModules( classLoader ); 152 final Specification s = model.getSpecification( specificationClass ); 153 154 if ( s == null ) 155 { 156 if ( this.isLoggable( Level.WARNING ) ) 157 { 158 this.log( classLoader, Level.WARNING, getMissingSpecificationMessage( 159 Locale.getDefault(), specificationClass.getName() ), null ); 160 161 } 162 163 return null; 164 } 165 166 if ( s.getMultiplicity() == Multiplicity.ONE && specification.isArray() ) 167 { 168 if ( this.isLoggable( Level.WARNING ) ) 169 { 170 this.log( classLoader, Level.WARNING, getIllegalArraySpecificationMessage( 171 Locale.getDefault(), s.getIdentifier(), s.getMultiplicity().value() ), null ); 172 173 } 174 175 return null; 176 } 177 178 if ( s.getMultiplicity() != Multiplicity.ONE && !specification.isArray() ) 179 { 180 if ( this.isLoggable( Level.WARNING ) ) 181 { 182 this.log( classLoader, Level.WARNING, getIllegalObjectSpecificationMessage( 183 Locale.getDefault(), s.getIdentifier(), s.getMultiplicity().value() ), null ); 184 185 } 186 187 return null; 188 } 189 190 Scope scope = null; 191 if ( s.getScope() != null ) 192 { 193 scope = this.getScope( s.getScope(), classLoader ); 194 195 if ( scope == null ) 196 { 197 if ( this.isLoggable( Level.WARNING ) ) 198 { 199 this.log( classLoader, Level.WARNING, getMissingScopeMessage( 200 Locale.getDefault(), s.getScope() ), null ); 201 202 } 203 204 return null; 205 } 206 } 207 208 final Implementations available = model.getImplementations( s.getIdentifier() ); 209 if ( available == null ) 210 { 211 if ( this.isLoggable( Level.WARNING ) ) 212 { 213 this.log( classLoader, Level.WARNING, getMissingImplementationsMessage( 214 Locale.getDefault(), s.getIdentifier() ), null ); 215 216 } 217 218 return null; 219 } 220 221 int idx = 0; 222 final Object[] array = new Object[ available.getImplementation().size() ]; 223 224 for ( int i = 0, s0 = available.getImplementation().size(); i < s0; i++ ) 225 { 226 final Implementation impl = available.getImplementation().get( i ); 227 228 if ( impl.getLocation() != null ) 229 { 230 if ( s.getClazz() == null ) 231 { 232 if ( this.isLoggable( Level.WARNING ) ) 233 { 234 this.log( classLoader, Level.WARNING, getMissingSpecificationClassMessage( 235 Locale.getDefault(), s.getIdentifier() ), null ); 236 237 } 238 239 return null; 240 } 241 242 final Object o = this.getObject( s.getJavaTypeName().getClass( classLoader, true ), 243 impl.getLocationUri(), classLoader ); 244 245 if ( o == null ) 246 { 247 if ( this.isLoggable( Level.WARNING ) ) 248 { 249 this.log( classLoader, Level.WARNING, getMissingObjectMessage( 250 Locale.getDefault(), impl.getIdentifier(), impl.getName() ), null ); 251 252 } 253 } 254 else if ( specificationClass.isInstance( o ) ) 255 { 256 array[idx++] = o; 257 } 258 } 259 else if ( !impl.isAbstract() ) 260 { 261 final Instance instance = model.getInstance( impl.getIdentifier() ); 262 if ( instance == null ) 263 { 264 if ( this.isLoggable( Level.WARNING ) ) 265 { 266 this.log( classLoader, Level.WARNING, getMissingInstanceMessage( 267 Locale.getDefault(), impl.getIdentifier(), impl.getName() ), null ); 268 269 } 270 271 return null; 272 } 273 274 final Object o = this.getObject( scope, instance, classLoader ); 275 if ( o == null ) 276 { 277 if ( this.isLoggable( Level.WARNING ) ) 278 { 279 this.log( classLoader, Level.WARNING, getMissingObjectMessage( 280 Locale.getDefault(), impl.getIdentifier(), impl.getName() ), null ); 281 282 } 283 } 284 else if ( specificationClass.isInstance( o ) ) 285 { 286 array[idx++] = o; 287 } 288 } 289 } 290 291 if ( specification.isArray() ) 292 { 293 @SuppressWarnings( "unchecked" ) 294 final T copy = (T) Array.newInstance( specificationClass, idx ); 295 System.arraycopy( array, 0, copy, 0, idx ); 296 return copy; 297 } 298 else if ( idx == 1 ) 299 { 300 @SuppressWarnings( "unchecked" ) 301 final T object = (T) array[0]; 302 return object; 303 } 304 305 return null; 306 } 307 catch ( final Exception e ) 308 { 309 throw new ObjectManagementException( getMessage( e ), e ); 310 } 311 } 312 313 public <T> T getObject( final Class<T> specification, final String implementationName ) 314 { 315 if ( specification == null ) 316 { 317 throw new NullPointerException( "specification" ); 318 } 319 if ( implementationName == null ) 320 { 321 throw new NullPointerException( "implementationName" ); 322 } 323 324 try 325 { 326 this.initialize(); 327 328 final ClassLoader classLoader = this.getDefaultClassLoader( specification ); 329 final Modules model = this.getModules( classLoader ); 330 final Specification s = model.getSpecification( specification ); 331 332 if ( s == null ) 333 { 334 if ( this.isLoggable( Level.WARNING ) ) 335 { 336 this.log( classLoader, Level.WARNING, getMissingSpecificationMessage( 337 Locale.getDefault(), specification.getName() ), null ); 338 339 } 340 341 return null; 342 } 343 344 Scope scope = null; 345 if ( s.getScope() != null ) 346 { 347 scope = this.getScope( s.getScope(), classLoader ); 348 349 if ( scope == null ) 350 { 351 if ( this.isLoggable( Level.WARNING ) ) 352 { 353 this.log( classLoader, Level.WARNING, getMissingScopeMessage( 354 Locale.getDefault(), s.getScope() ), null ); 355 356 } 357 358 return null; 359 } 360 } 361 362 final Implementations available = model.getImplementations( s.getIdentifier() ); 363 if ( available == null ) 364 { 365 if ( this.isLoggable( Level.WARNING ) ) 366 { 367 this.log( classLoader, Level.WARNING, getMissingImplementationsMessage( 368 Locale.getDefault(), specification.getName() ), null ); 369 370 } 371 372 return null; 373 } 374 375 final Implementation i = available.getImplementationByName( implementationName ); 376 if ( i == null ) 377 { 378 if ( this.isLoggable( Level.WARNING ) ) 379 { 380 this.log( classLoader, Level.WARNING, getMissingImplementationMessage( 381 Locale.getDefault(), s.getIdentifier(), implementationName ), null ); 382 383 } 384 385 return null; 386 } 387 388 if ( i.getLocation() != null ) 389 { 390 if ( s.getClazz() == null ) 391 { 392 if ( this.isLoggable( Level.WARNING ) ) 393 { 394 this.log( classLoader, Level.WARNING, getMissingSpecificationClassMessage( 395 Locale.getDefault(), s.getIdentifier() ), null ); 396 397 } 398 399 return null; 400 } 401 402 final T object = this.getObject( s.getJavaTypeName().getClass( classLoader, true ). 403 asSubclass( specification ), i.getLocationUri(), classLoader ); 404 405 if ( object == null ) 406 { 407 if ( this.isLoggable( Level.WARNING ) ) 408 { 409 this.log( classLoader, Level.WARNING, getMissingObjectMessage( 410 Locale.getDefault(), i.getIdentifier(), i.getName() ), null ); 411 412 } 413 414 return null; 415 } 416 417 return object; 418 } 419 else if ( !i.isAbstract() ) 420 { 421 final Instance instance = model.getInstance( i.getIdentifier() ); 422 if ( instance == null ) 423 { 424 if ( this.isLoggable( Level.WARNING ) ) 425 { 426 this.log( classLoader, Level.WARNING, getMissingInstanceMessage( 427 Locale.getDefault(), i.getIdentifier(), i.getName() ), null ); 428 429 } 430 431 return null; 432 } 433 434 final Object object = this.getObject( scope, instance, classLoader ); 435 if ( object == null ) 436 { 437 if ( this.isLoggable( Level.WARNING ) ) 438 { 439 this.log( classLoader, Level.WARNING, getMissingObjectMessage( 440 Locale.getDefault(), i.getIdentifier(), i.getName() ), null ); 441 442 } 443 444 return null; 445 } 446 else if ( specification.isInstance( object ) ) 447 { 448 @SuppressWarnings( "unchecked" ) 449 final T o = (T) object; 450 return o; 451 } 452 } 453 454 return null; 455 } 456 catch ( final Exception e ) 457 { 458 throw new ObjectManagementException( getMessage( e ), e ); 459 } 460 } 461 462 public Object getDependency( final Object object, final String dependencyName ) 463 { 464 if ( object == null ) 465 { 466 throw new NullPointerException( "object" ); 467 } 468 if ( dependencyName == null ) 469 { 470 throw new NullPointerException( "dependencyName" ); 471 } 472 473 try 474 { 475 this.initialize(); 476 477 final ClassLoader classLoader = this.getDefaultClassLoader( object.getClass() ); 478 final Modules model = this.getModules( classLoader ); 479 final Instance instance = model.getInstance( object ); 480 481 if ( instance == null ) 482 { 483 if ( this.isLoggable( Level.WARNING ) ) 484 { 485 this.log( classLoader, Level.WARNING, getMissingObjectInstanceMessage( 486 Locale.getDefault(), this.getObjectInfo( object ) ), null ); 487 488 } 489 490 return null; 491 } 492 493 synchronized ( instance ) 494 { 495 final Dependency dependency = instance.getDependencies() != null 496 ? instance.getDependencies().getDependency( dependencyName ) : null; 497 498 if ( dependency == null ) 499 { 500 if ( this.isLoggable( Level.WARNING ) ) 501 { 502 this.log( classLoader, Level.WARNING, getMissingDependencyMessage( 503 Locale.getDefault(), instance.getIdentifier(), dependencyName ), null ); 504 505 } 506 507 return null; 508 } 509 510 Object o = instance.getDependencyObjects().get( dependencyName ); 511 if ( o == null && !instance.getDependencyObjects().containsKey( dependencyName ) ) 512 { 513 final Specification ds = model.getSpecification( dependency.getIdentifier() ); 514 if ( ds == null ) 515 { 516 if ( this.isLoggable( Level.WARNING ) ) 517 { 518 this.log( classLoader, Level.WARNING, getMissingSpecificationMessage( 519 Locale.getDefault(), dependency.getIdentifier() ), null ); 520 521 } 522 523 return null; 524 } 525 526 Scope scope = null; 527 if ( ds.getScope() != null ) 528 { 529 scope = this.getScope( ds.getScope(), classLoader ); 530 531 if ( scope == null ) 532 { 533 if ( this.isLoggable( Level.WARNING ) ) 534 { 535 this.log( classLoader, Level.WARNING, getMissingScopeMessage( 536 Locale.getDefault(), ds.getScope() ), null ); 537 538 } 539 540 return null; 541 } 542 } 543 544 final Implementations available = model.getImplementations( ds.getIdentifier() ); 545 if ( available == null ) 546 { 547 if ( !dependency.isOptional() && this.isLoggable( Level.WARNING ) ) 548 { 549 this.log( classLoader, Level.WARNING, getMissingImplementationsMessage( 550 Locale.getDefault(), dependency.getIdentifier() ), null ); 551 552 } 553 554 return null; 555 } 556 557 if ( dependency.getImplementationName() != null ) 558 { 559 final Implementation i = 560 available.getImplementationByName( dependency.getImplementationName() ); 561 562 if ( i == null ) 563 { 564 if ( !dependency.isOptional() && this.isLoggable( Level.WARNING ) ) 565 { 566 this.log( classLoader, Level.WARNING, getMissingImplementationMessage( 567 Locale.getDefault(), dependency.getIdentifier(), 568 dependency.getImplementationName() ), null ); 569 570 } 571 572 return null; 573 } 574 575 if ( i.getLocation() != null ) 576 { 577 if ( ds.getClazz() == null ) 578 { 579 if ( this.isLoggable( Level.WARNING ) ) 580 { 581 this.log( classLoader, Level.WARNING, getMissingSpecificationClassMessage( 582 Locale.getDefault(), ds.getIdentifier() ), null ); 583 584 } 585 586 return null; 587 } 588 589 o = this.getObject( ds.getJavaTypeName().getClass( classLoader, true ), i.getLocationUri(), 590 classLoader ); 591 592 if ( o == null ) 593 { 594 if ( this.isLoggable( Level.WARNING ) ) 595 { 596 this.log( classLoader, Level.WARNING, getMissingObjectMessage( 597 Locale.getDefault(), i.getIdentifier(), i.getName() ), null ); 598 599 } 600 601 return null; 602 } 603 } 604 else if ( !i.isAbstract() ) 605 { 606 final Instance di = model.getInstance( i.getIdentifier(), dependency ); 607 if ( di == null ) 608 { 609 if ( this.isLoggable( Level.WARNING ) ) 610 { 611 this.log( classLoader, Level.WARNING, getMissingInstanceMessage( 612 Locale.getDefault(), i.getIdentifier(), i.getName() ), null ); 613 614 } 615 616 return null; 617 } 618 619 o = this.getObject( scope, di, classLoader ); 620 if ( o == null ) 621 { 622 if ( this.isLoggable( Level.WARNING ) ) 623 { 624 this.log( classLoader, Level.WARNING, getMissingObjectMessage( 625 Locale.getDefault(), i.getIdentifier(), i.getName() ), null ); 626 627 } 628 629 return null; 630 } 631 } 632 } 633 else if ( ds.getMultiplicity() == Multiplicity.ONE ) 634 { 635 if ( available.getImplementation().size() == 1 ) 636 { 637 final Implementation ref = available.getImplementation().get( 0 ); 638 639 if ( ref.getLocation() != null ) 640 { 641 if ( ds.getClazz() == null ) 642 { 643 if ( this.isLoggable( Level.WARNING ) ) 644 { 645 this.log( classLoader, Level.WARNING, getMissingSpecificationClassMessage( 646 Locale.getDefault(), ds.getIdentifier() ), null ); 647 648 } 649 650 return null; 651 } 652 653 o = this.getObject( ds.getJavaTypeName().getClass( classLoader, true ), 654 ref.getLocationUri(), classLoader ); 655 656 if ( o == null ) 657 { 658 if ( this.isLoggable( Level.WARNING ) ) 659 { 660 this.log( classLoader, Level.WARNING, getMissingObjectMessage( 661 Locale.getDefault(), ref.getIdentifier(), ref.getName() ), null ); 662 663 } 664 665 return null; 666 } 667 } 668 else if ( !ref.isAbstract() ) 669 { 670 final Instance di = model.getInstance( ref.getIdentifier(), dependency ); 671 if ( di == null ) 672 { 673 if ( this.isLoggable( Level.WARNING ) ) 674 { 675 this.log( classLoader, Level.WARNING, getMissingInstanceMessage( 676 Locale.getDefault(), ref.getIdentifier(), ref.getName() ), null ); 677 678 } 679 680 return null; 681 } 682 683 o = this.getObject( scope, di, classLoader ); 684 if ( o == null ) 685 { 686 if ( this.isLoggable( Level.WARNING ) ) 687 { 688 this.log( classLoader, Level.WARNING, getMissingObjectMessage( 689 Locale.getDefault(), ref.getIdentifier(), ref.getName() ), null ); 690 691 } 692 693 return null; 694 } 695 } 696 } 697 else 698 { 699 this.log( classLoader, Level.WARNING, getUnexpectedDependencyObjectsMessage( 700 Locale.getDefault(), instance.getIdentifier(), dependencyName, BigInteger.ONE, 701 available.getImplementation().size() ), null ); 702 703 } 704 } 705 else 706 { 707 int idx = 0; 708 final Object[] array = new Object[ available.getImplementation().size() ]; 709 710 if ( !available.getImplementation().isEmpty() && ds.getClazz() == null ) 711 { 712 if ( this.isLoggable( Level.WARNING ) ) 713 { 714 this.log( classLoader, Level.WARNING, getMissingSpecificationClassMessage( 715 Locale.getDefault(), ds.getIdentifier() ), null ); 716 717 } 718 719 return null; 720 } 721 722 for ( int i = 0, s0 = available.getImplementation().size(); i < s0; i++ ) 723 { 724 final Implementation a = available.getImplementation().get( i ); 725 if ( a.getLocation() != null ) 726 { 727 if ( ds.getClazz() == null ) 728 { 729 if ( this.isLoggable( Level.WARNING ) ) 730 { 731 this.log( classLoader, Level.WARNING, getMissingSpecificationClassMessage( 732 Locale.getDefault(), ds.getIdentifier() ), null ); 733 734 } 735 736 return null; 737 } 738 739 final Object o2 = this.getObject( ds.getJavaTypeName().getClass( classLoader, true ), 740 a.getLocationUri(), classLoader ); 741 742 if ( o2 == null ) 743 { 744 if ( this.isLoggable( Level.WARNING ) ) 745 { 746 this.log( classLoader, Level.WARNING, getMissingObjectMessage( 747 Locale.getDefault(), a.getIdentifier(), a.getName() ), null ); 748 749 } 750 } 751 else 752 { 753 array[idx++] = o2; 754 } 755 } 756 else if ( !a.isAbstract() ) 757 { 758 final Instance di = model.getInstance( a.getIdentifier(), dependency ); 759 if ( di == null ) 760 { 761 if ( this.isLoggable( Level.WARNING ) ) 762 { 763 this.log( classLoader, Level.WARNING, getMissingInstanceMessage( 764 Locale.getDefault(), a.getIdentifier(), a.getName() ), null ); 765 766 } 767 768 return null; 769 } 770 771 final Object o2 = this.getObject( scope, di, classLoader ); 772 if ( o2 == null ) 773 { 774 if ( this.isLoggable( Level.WARNING ) ) 775 { 776 this.log( classLoader, Level.WARNING, getMissingObjectMessage( 777 Locale.getDefault(), a.getIdentifier(), a.getName() ), null ); 778 779 } 780 } 781 else 782 { 783 array[idx++] = o2; 784 } 785 } 786 } 787 788 if ( idx > 0 ) 789 { 790 o = Array.newInstance( ds.getJavaTypeName().getClass( classLoader, true ), idx ); 791 System.arraycopy( array, 0, o, 0, idx ); 792 } 793 else 794 { 795 o = null; 796 } 797 } 798 } 799 800 if ( dependency.isBound() ) 801 { 802 instance.getDependencyObjects().put( dependencyName, o ); 803 } 804 805 return o; 806 } 807 } 808 catch ( final Exception e ) 809 { 810 throw new ObjectManagementException( getMessage( e ), e ); 811 } 812 } 813 814 public Object getProperty( final Object object, final String propertyName ) 815 { 816 if ( object == null ) 817 { 818 throw new NullPointerException( "object" ); 819 } 820 if ( propertyName == null ) 821 { 822 throw new NullPointerException( "propertyName" ); 823 } 824 825 try 826 { 827 this.initialize(); 828 829 final ClassLoader classLoader = this.getDefaultClassLoader( object.getClass() ); 830 final Modules model = this.getModules( classLoader ); 831 final Instance instance = model.getInstance( object ); 832 833 if ( instance == null ) 834 { 835 if ( this.isLoggable( Level.WARNING ) ) 836 { 837 this.log( classLoader, Level.WARNING, getMissingObjectInstanceMessage( 838 Locale.getDefault(), this.getObjectInfo( object ) ), null ); 839 840 } 841 842 return null; 843 } 844 845 synchronized ( instance ) 846 { 847 Object value = instance.getPropertyObjects().get( propertyName ); 848 849 if ( value == null && !instance.getPropertyObjects().containsKey( propertyName ) ) 850 { 851 final Property property = 852 instance.getProperties() != null ? instance.getProperties().getProperty( propertyName ) : null; 853 854 if ( property == null ) 855 { 856 if ( this.isLoggable( Level.WARNING ) ) 857 { 858 this.log( classLoader, Level.WARNING, getMissingPropertyMessage( 859 Locale.getDefault(), instance.getIdentifier(), propertyName ), null ); 860 861 } 862 863 return null; 864 } 865 866 value = property.getJavaValue( classLoader ); 867 instance.getPropertyObjects().put( propertyName, value ); 868 } 869 870 return value; 871 } 872 } 873 catch ( final Exception e ) 874 { 875 throw new ObjectManagementException( getMessage( e ), e ); 876 } 877 } 878 879 public String getMessage( final Object object, final String messageName, final Locale locale, 880 final Object... arguments ) 881 { 882 if ( object == null ) 883 { 884 throw new NullPointerException( "object" ); 885 } 886 if ( messageName == null ) 887 { 888 throw new NullPointerException( "messageName" ); 889 } 890 if ( locale == null ) 891 { 892 throw new NullPointerException( "locale" ); 893 } 894 895 try 896 { 897 this.initialize(); 898 899 final ClassLoader classLoader = this.getDefaultClassLoader( object.getClass() ); 900 final Modules model = this.getModules( classLoader ); 901 final Instance instance = model.getInstance( object ); 902 903 if ( instance == null ) 904 { 905 if ( this.isLoggable( Level.WARNING ) ) 906 { 907 this.log( classLoader, Level.WARNING, getMissingObjectInstanceMessage( 908 Locale.getDefault(), this.getObjectInfo( object ) ), null ); 909 910 } 911 912 return null; 913 } 914 915 synchronized ( instance ) 916 { 917 Map<Locale, MessageFormat> messageFormats = instance.getMessageObjects().get( messageName ); 918 919 if ( messageFormats == null ) 920 { 921 messageFormats = new HashMap<Locale, MessageFormat>(); 922 instance.getMessageObjects().put( messageName, messageFormats ); 923 } 924 925 MessageFormat messageFormat = messageFormats.get( locale ); 926 927 if ( messageFormat == null && !messageFormats.containsKey( locale ) ) 928 { 929 final Message message = 930 instance.getMessages() != null ? instance.getMessages().getMessage( messageName ) : null; 931 932 if ( message == null || message.getTemplate() == null ) 933 { 934 if ( this.isLoggable( Level.WARNING ) ) 935 { 936 this.log( classLoader, Level.WARNING, getMissingMessageMessage( 937 Locale.getDefault(), instance.getIdentifier(), messageName ), null ); 938 939 } 940 } 941 else 942 { 943 messageFormat = message.getJavaMessage( locale ); 944 } 945 946 messageFormats.put( locale, messageFormat ); 947 } 948 949 if ( messageFormat != null ) 950 { 951 synchronized ( messageFormat ) 952 { 953 return messageFormat.format( arguments ); 954 } 955 } 956 } 957 958 return null; 959 } 960 catch ( final Exception e ) 961 { 962 throw new ObjectManagementException( getMessage( e ), e ); 963 } 964 } 965 966 // SECTION-END 967 // SECTION-START[DefaultObjectManager] 968 /** Constant for the {@code Singleton} scope identifier. */ 969 protected static final String SINGLETON_SCOPE_IDENTIFIER = "Singleton"; 970 971 /** 972 * Array holding a single {@code InvocationHandler} class. 973 * @since 1.2 974 */ 975 private static final Class<?>[] INVOCATION_HANDLER_ARGUMENTS = 976 { 977 InvocationHandler.class 978 }; 979 980 /** 981 * Log level events are logged at by default. 982 * @see #getDefaultLogLevel() 983 */ 984 private static final Level DEFAULT_LOG_LEVEL = Level.WARNING; 985 986 /** Default log level. */ 987 private static volatile Level defaultLogLevel; 988 989 /** Name of the platform's bootstrap class loader class. */ 990 private static volatile String bootstrapClassLoaderClassName; 991 992 private static volatile boolean bootstrapClassLoaderClassNameInitialized; 993 994 /** 995 * Identifier of the model to search for modules by default. 996 * @since 1.1 997 */ 998 private static volatile String defaultModelIdentifier; 999 1000 /** 1001 * Identifier of the model to search for modules. 1002 * @since 1.1 1003 */ 1004 private String modelIdentifier; 1005 1006 /** 1007 * Flag indicating model object class path resolution is enabled by default. 1008 * @since 1.1 1009 */ 1010 private static volatile Boolean defaultModelObjectClasspathResolutionEnabled; 1011 1012 /** 1013 * Flag indicating model object class path resolution is enabled. 1014 * @since 1.1 1015 */ 1016 private Boolean modelObjectClasspathResolutionEnabled; 1017 1018 /** 1019 * Flag indicating model processing is enabled by default. 1020 * @since 1.1 1021 */ 1022 private static volatile Boolean defaultModelProcessingEnabled; 1023 1024 /** 1025 * Flag indicating model processing is enabled. 1026 * @since 1.1 1027 */ 1028 private Boolean modelProcessingEnabled; 1029 1030 /** {@code ClassLoader} instance representing the bootstrap class loader. */ 1031 private static final ClassLoader BOOTSTRAP_CLASSLOADER = new ClassLoader( null ) 1032 { 1033 1034 @Override 1035 public String toString() 1036 { 1037 return DefaultObjectManager.class.getName() + ".BootstrapClassLoader@" 1038 + Integer.toHexString( this.hashCode() ); 1039 1040 } 1041 1042 }; 1043 1044 /** Flag indicating that initialization has been performed. */ 1045 private boolean initialized; 1046 1047 /** Log level of the instance. */ 1048 private Level logLevel; 1049 1050 /** Listeners of the instance. */ 1051 private final Map<ClassLoader, List<Listener>> listeners = 1052 new WeakIdentityHashMap<ClassLoader, List<Listener>>(); 1053 1054 /** Modules of the instance. */ 1055 private final Map<ClassLoader, Modules> modules = 1056 new WeakIdentityHashMap<ClassLoader, Modules>(); 1057 1058 /** Invokers of the instance. */ 1059 private final Map<ClassLoader, Invoker> invokers = 1060 new WeakIdentityHashMap<ClassLoader, Invoker>(); 1061 1062 /** Scopes of the instance. */ 1063 private final Map<ClassLoader, Map<String, Scope>> scopes = 1064 new WeakIdentityHashMap<ClassLoader, Map<String, Scope>>(); 1065 1066 /** Locators of the instance. */ 1067 private final Map<ClassLoader, Map<String, Locator>> locators = 1068 new WeakIdentityHashMap<ClassLoader, Map<String, Locator>>(); 1069 1070 /** Objects of the instance. */ 1071 private final Map<ClassLoader, Map<Object, Instance>> objects = 1072 new WeakIdentityHashMap<ClassLoader, Map<Object, Instance>>(); 1073 1074 /** {@code ObjectManager} singletons. */ 1075 private static final Map<ClassLoader, ObjectManager> singletons = 1076 new WeakIdentityHashMap<ClassLoader, ObjectManager>(); 1077 1078 /** 1079 * Default class loaders cache. 1080 * @since 1.2 1081 */ 1082 private static final Map<ClassLoader, Reference<ClassLoader>> defaultClassLoaders = 1083 new WeakIdentityHashMap<ClassLoader, Reference<ClassLoader>>(); 1084 1085 /** 1086 * Proxy class constructors by class loader any instance cache. 1087 * @since 1.2 1088 */ 1089 private static final Map<ClassLoader, Map<String, Reference<Constructor<?>>>> proxyClassConstructors = 1090 new WeakIdentityHashMap<ClassLoader, Map<String, Reference<Constructor<?>>>>(); 1091 1092 /** 1093 * Default {@link ObjectManagerFactory#getObjectManager(ClassLoader)} implementation. 1094 * 1095 * @param classLoader The class loader to use for getting the singleton instance; {@code null} to use the platform's 1096 * bootstrap class loader. 1097 * 1098 * @return The default {@code ObjectManager} singleton instance. 1099 * 1100 * @see ObjectManagerFactory#getObjectManager(ClassLoader) 1101 */ 1102 public static ObjectManager getObjectManager( final ClassLoader classLoader ) 1103 { 1104 ObjectManager manager; 1105 final ClassLoader singletonsLoader = getClassLoader( classLoader ); 1106 1107 synchronized ( singletons ) 1108 { 1109 manager = singletons.get( singletonsLoader ); 1110 1111 if ( manager == null ) 1112 { 1113 manager = ObjectManagerFactory.newObjectManager( classLoader ); 1114 1115 if ( singletons.put( singletonsLoader, manager ) != null ) 1116 { 1117 throw new AssertionError( getScopeContentionFailure( 1118 Locale.getDefault(), manager.getClass().getName() ) ); 1119 1120 } 1121 } 1122 } 1123 1124 return manager.getObject( ObjectManager.class ); 1125 } 1126 1127 /** 1128 * Gets the list of listeners registered with the class loader of the instance. 1129 * <p>Calling this method is the same as calling<blockquote><pre> 1130 * getListeners( getClassLoader( getClass() ) );</pre></blockquote> 1131 * 1132 * @return The list of registered listeners. 1133 * 1134 * @throws ObjectManagementException if getting the list of listeners fails. 1135 * 1136 * @see #getListeners(java.lang.ClassLoader) 1137 */ 1138 public List<Listener> getListeners() 1139 { 1140 return this.getListeners( this.getDefaultClassLoader( this.getClass() ) ); 1141 } 1142 1143 /** 1144 * Gets the list of listeners registered with a given class loader. 1145 * 1146 * @param classLoader The class loader to get registered listeners of. 1147 * 1148 * @return The list of listeners registered with {@code classLoader}. 1149 * 1150 * @throws NullPointerException if {@code classLoader} is {@code null}. 1151 * @throws ObjectManagementException if getting the list of listeners fails. 1152 * 1153 * @see #getDefaultListener(org.jomc.model.Modules) 1154 * 1155 * @since 1.1 1156 */ 1157 public List<Listener> getListeners( final ClassLoader classLoader ) 1158 { 1159 if ( classLoader == null ) 1160 { 1161 throw new NullPointerException( "classLoader" ); 1162 } 1163 1164 try 1165 { 1166 final ClassLoader listenersLoader = this.getDefaultClassLoader( classLoader ); 1167 1168 synchronized ( this.listeners ) 1169 { 1170 List<Listener> cachedListeners = this.listeners.get( listenersLoader ); 1171 1172 if ( cachedListeners == null ) 1173 { 1174 final List<LogRecord> bootstrapRecords = new ArrayList<LogRecord>( 1024 ); 1175 final Listener bootstrapListener = new Listener() 1176 { 1177 1178 public void onLog( final Level level, final String message, final Throwable throwable ) 1179 { 1180 final LogRecord r = new LogRecord( level, message ); 1181 r.setThrown( throwable ); 1182 1183 bootstrapRecords.add( r ); 1184 } 1185 1186 }; 1187 1188 cachedListeners = new LinkedList<Listener>(); 1189 cachedListeners.add( bootstrapListener ); 1190 this.listeners.put( listenersLoader, cachedListeners ); 1191 1192 final List<Listener> modelListeners = new LinkedList<Listener>(); 1193 final Modules model = this.getModules( classLoader ); 1194 final Specification listenerSpecification = model.getSpecification( Listener.class ); 1195 1196 if ( listenerSpecification != null ) 1197 { 1198 final Implementations implementations = 1199 model.getImplementations( listenerSpecification.getIdentifier() ); 1200 1201 if ( implementations != null && !implementations.getImplementation().isEmpty() ) 1202 { 1203 for ( int i = 0, s0 = implementations.getImplementation().size(); i < s0; i++ ) 1204 { 1205 final Implementation impl = implementations.getImplementation().get( i ); 1206 final Instance listenerInstance = model.getInstance( impl.getIdentifier() ); 1207 if ( listenerInstance != null ) 1208 { 1209 try 1210 { 1211 final Listener l = 1212 (Listener) model.createObject( listenerInstance, classLoader ); 1213 1214 modelListeners.add( l ); 1215 1216 if ( this.isLoggable( Level.CONFIG ) ) 1217 { 1218 this.log( classLoader, Level.CONFIG, getListenerInfoMessage( 1219 Locale.getDefault(), l.getClass().getName(), 1220 this.getClassLoaderInfo( classLoader, listenersLoader ) ), null ); 1221 1222 } 1223 } 1224 catch ( final InstantiationException e ) 1225 { 1226 if ( this.isLoggable( Level.SEVERE ) ) 1227 { 1228 this.log( classLoader, Level.SEVERE, getMessage( e ), e ); 1229 } 1230 } 1231 } 1232 else if ( this.isLoggable( Level.WARNING ) ) 1233 { 1234 this.log( classLoader, Level.WARNING, getMissingInstanceMessage( 1235 Locale.getDefault(), impl.getIdentifier(), impl.getName() ), null ); 1236 1237 } 1238 } 1239 } 1240 else if ( this.isLoggable( Level.WARNING ) ) 1241 { 1242 this.log( classLoader, Level.WARNING, getMissingImplementationsMessage( 1243 Locale.getDefault(), listenerSpecification.getIdentifier() ), null ); 1244 1245 } 1246 } 1247 else if ( this.isLoggable( Level.WARNING ) ) 1248 { 1249 this.log( classLoader, Level.WARNING, getMissingSpecificationMessage( 1250 Locale.getDefault(), Listener.class.getName() ), null ); 1251 1252 } 1253 1254 cachedListeners.remove( bootstrapListener ); 1255 cachedListeners.addAll( modelListeners ); 1256 1257 if ( cachedListeners.isEmpty() ) 1258 { 1259 if ( !classLoader.equals( this.getDefaultClassLoader( this.getClass() ) ) ) 1260 { 1261 cachedListeners.addAll( this.getListeners() ); 1262 } 1263 else 1264 { 1265 cachedListeners.add( this.getDefaultListener( model ) ); 1266 1267 if ( this.isLoggable( Level.CONFIG ) ) 1268 { 1269 this.log( Level.CONFIG, getDefaultListenerInfo( 1270 Locale.getDefault(), this.getClassLoaderInfo( classLoader, listenersLoader ) ), 1271 null ); 1272 1273 } 1274 } 1275 } 1276 1277 for ( LogRecord r : bootstrapRecords ) 1278 { 1279 this.log( classLoader, r.getLevel(), r.getMessage(), r.getThrown() ); 1280 } 1281 } 1282 1283 return cachedListeners; 1284 } 1285 } 1286 catch ( final ModelObjectException e ) 1287 { 1288 throw new ObjectManagementException( getMessage( e ), e ); 1289 } 1290 } 1291 1292 /** 1293 * Gets a new default listener implementation instance. 1294 * 1295 * @return A new default listener implementation instance. 1296 * 1297 * @see #getListeners() 1298 * @see #getListeners(java.lang.ClassLoader) 1299 * 1300 * @since 1.1 1301 * 1302 * @deprecated As of JOMC 1.2, replaced by method {@link #getDefaultListener(org.jomc.model.Modules)}. This method 1303 * will be removed in version 2.0. 1304 */ 1305 @Deprecated 1306 public Listener getDefaultListener() 1307 { 1308 return new DefaultListener(); 1309 } 1310 1311 /** 1312 * Gets a new default listener implementation instance. 1313 * 1314 * @param model The model to get a new default listener implementation instance of. 1315 * 1316 * @return A new default listener implementation instance. 1317 * 1318 * @throws NullPointerException if {@code model} is {@code null}. 1319 * @throws ObjectManagementException if getting a new default listener implementation instance fails. 1320 * 1321 * @see #getListeners() 1322 * @see #getListeners(java.lang.ClassLoader) 1323 * 1324 * @since 1.2 1325 */ 1326 public Listener getDefaultListener( final Modules model ) 1327 { 1328 if ( model == null ) 1329 { 1330 throw new NullPointerException( "model" ); 1331 } 1332 1333 try 1334 { 1335 final Listener defaultListener = new DefaultListener(); 1336 model.getInstance( defaultListener ); 1337 return defaultListener; 1338 } 1339 catch ( final ModelObjectException e ) 1340 { 1341 throw new ObjectManagementException( getMessage( e ), e ); 1342 } 1343 } 1344 1345 /** 1346 * Gets the default log level events are logged at. 1347 * <p>The default log level is controlled by system property 1348 * {@code org.jomc.ri.DefaultObjectManager.defaultLogLevel} holding the log level to log events at by default. 1349 * If that property is not set, the {@code WARNING} default is returned.</p> 1350 * 1351 * @return The log level events are logged at by default. 1352 * 1353 * @see #getLogLevel() 1354 * @see Level#parse(java.lang.String) 1355 */ 1356 public static Level getDefaultLogLevel() 1357 { 1358 if ( defaultLogLevel == null ) 1359 { 1360 defaultLogLevel = Level.parse( System.getProperty( "org.jomc.ri.DefaultObjectManager.defaultLogLevel", 1361 DEFAULT_LOG_LEVEL.getName() ) ); 1362 1363 } 1364 1365 return defaultLogLevel; 1366 } 1367 1368 /** 1369 * Sets the default log level events are logged at. 1370 * 1371 * @param value The new default level events are logged at or {@code null}. 1372 * 1373 * @see #getDefaultLogLevel() 1374 */ 1375 public static void setDefaultLogLevel( final Level value ) 1376 { 1377 defaultLogLevel = value; 1378 } 1379 1380 /** 1381 * Gets the log level of the instance. 1382 * 1383 * @return The log level of the instance. 1384 * 1385 * @see #getDefaultLogLevel() 1386 * @see #setLogLevel(java.util.logging.Level) 1387 * @see #isLoggable(java.util.logging.Level) 1388 */ 1389 public final Level getLogLevel() 1390 { 1391 if ( this.logLevel == null ) 1392 { 1393 this.logLevel = getDefaultLogLevel(); 1394 1395 if ( this.isLoggable( Level.CONFIG ) ) 1396 { 1397 this.log( Level.CONFIG, getDefaultLogLevelInfoMessage( 1398 Locale.getDefault(), this.logLevel.getLocalizedName() ), null ); 1399 1400 } 1401 } 1402 1403 return this.logLevel; 1404 } 1405 1406 /** 1407 * Sets the log level of the instance. 1408 * 1409 * @param value The new log level of the instance or {@code null}. 1410 * 1411 * @see #getLogLevel() 1412 * @see #isLoggable(java.util.logging.Level) 1413 */ 1414 public final void setLogLevel( final Level value ) 1415 { 1416 this.logLevel = value; 1417 } 1418 1419 /** 1420 * Checks if a message at a given level is provided to the listeners of the instance. 1421 * 1422 * @param level The level to test. 1423 * 1424 * @return {@code true}, if messages at {@code level} are provided to the listeners of the instance; 1425 * {@code false}, if messages at {@code level} are not provided to the listeners of the instance. 1426 * 1427 * @throws NullPointerException if {@code level} is {@code null}. 1428 * 1429 * @see #getLogLevel() 1430 * @see #setLogLevel(java.util.logging.Level) 1431 * @see #log(java.util.logging.Level, java.lang.String, java.lang.Throwable) 1432 * @see #log(java.lang.ClassLoader, java.util.logging.Level, java.lang.String, java.lang.Throwable) 1433 */ 1434 public boolean isLoggable( final Level level ) 1435 { 1436 if ( level == null ) 1437 { 1438 throw new NullPointerException( "level" ); 1439 } 1440 1441 return level.intValue() >= this.getLogLevel().intValue(); 1442 } 1443 1444 /** 1445 * Notifies listeners registered with the class loader of the instance. 1446 * <p>Calling this method is the same as calling<blockquote><pre> 1447 * log( getClassLoader( getClass() ), level, message, throwable );</pre></blockquote></p> 1448 * 1449 * @param level The level of the event. 1450 * @param message The message of the event or {@code null}. 1451 * @param throwable The throwable of the event or {@code null}. 1452 * 1453 * @throws NullPointerException if {@code level} is {@code null}. 1454 * @throws ObjectManagementException if notifying listeners fails. 1455 * 1456 * @see #log(java.lang.ClassLoader, java.util.logging.Level, java.lang.String, java.lang.Throwable) 1457 */ 1458 public void log( final Level level, final String message, final Throwable throwable ) 1459 { 1460 this.log( this.getDefaultClassLoader( this.getClass() ), level, message, throwable ); 1461 } 1462 1463 /** 1464 * Notifies listeners registered with a given class loader. 1465 * 1466 * @param classLoader The class loader to notify listeners of. 1467 * @param level The level of the event. 1468 * @param message The message of the event or {@code null}. 1469 * @param throwable The throwable of the event or {@code null}. 1470 * 1471 * @throws NullPointerException if {@code classLoader} or {@code level} is {@code null}. 1472 * @throws ObjectManagementException if notifying listeners fails. 1473 * 1474 * @since 1.1 1475 */ 1476 public void log( final ClassLoader classLoader, final Level level, final String message, final Throwable throwable ) 1477 { 1478 if ( level == null ) 1479 { 1480 throw new NullPointerException( "level" ); 1481 } 1482 if ( classLoader == null ) 1483 { 1484 throw new NullPointerException( "classLoader" ); 1485 } 1486 1487 if ( this.isLoggable( level ) ) 1488 { 1489 final List<Listener> l = this.getListeners( classLoader ); 1490 1491 for ( int i = 0, s0 = l.size(); i < s0; i++ ) 1492 { 1493 l.get( i ).onLog( level, message, throwable ); 1494 } 1495 } 1496 } 1497 1498 /** 1499 * Gets the identifier of the model to search for modules by default. 1500 * <p>The identifier of the model to search for modules by default is controlled by system property 1501 * {@code org.jomc.ri.DefaultObjectManager.defaultModelIdentifier} holding the identifier of the model to search for 1502 * modules by default. If that property is not set, the {@code http://jomc.org/model} default is returned.</p> 1503 * 1504 * @return The identifier of the model to search for modules by default. 1505 * 1506 * @see #getModelIdentifier() 1507 * @see #setDefaultModelIdentifier(java.lang.String) 1508 * @see ModelObject#MODEL_PUBLIC_ID 1509 * 1510 * @since 1.1 1511 */ 1512 public static String getDefaultModelIdentifier() 1513 { 1514 if ( defaultModelIdentifier == null ) 1515 { 1516 defaultModelIdentifier = System.getProperty( "org.jomc.ri.DefaultObjectManager.defaultModelIdentifier", 1517 ModelObject.MODEL_PUBLIC_ID ); 1518 1519 } 1520 1521 return defaultModelIdentifier; 1522 } 1523 1524 /** 1525 * Sets the identifier of the model to search for modules by default. 1526 * 1527 * @param value The new identifier of the model to search for modules by default or {@code null}. 1528 * 1529 * @see #getDefaultModelIdentifier() 1530 * 1531 * @since 1.1 1532 */ 1533 public static void setDefaultModelIdentifier( final String value ) 1534 { 1535 defaultModelIdentifier = value; 1536 } 1537 1538 /** 1539 * Gets the identifier of the model to search for modules. 1540 * 1541 * @return The identifier of the model to search for modules. 1542 * 1543 * @see #getDefaultModelIdentifier() 1544 * @see #setModelIdentifier(java.lang.String) 1545 * 1546 * @since 1.1 1547 */ 1548 public final String getModelIdentifier() 1549 { 1550 if ( this.modelIdentifier == null ) 1551 { 1552 this.modelIdentifier = getDefaultModelIdentifier(); 1553 1554 if ( this.isLoggable( Level.CONFIG ) ) 1555 { 1556 this.log( Level.CONFIG, getDefaultModelIdentifierInfo( 1557 Locale.getDefault(), this.modelIdentifier ), null ); 1558 1559 } 1560 } 1561 1562 return this.modelIdentifier; 1563 } 1564 1565 /** 1566 * Sets the identifier of the model to search for modules. 1567 * 1568 * @param value The new identifier of the model to search for modules or {@code null}. 1569 * 1570 * @since 1.1 1571 */ 1572 public final void setModelIdentifier( final String value ) 1573 { 1574 this.modelIdentifier = value; 1575 } 1576 1577 /** 1578 * Gets a flag indicating model object class path resolution is enabled by default. 1579 * <p>The default model object class path resolution enabled flag is controlled by system property 1580 * {@code org.jomc.ri.DefaultObjectManager.defaultModelObjectClasspathResolutionEnabled} holding a boolean 1581 * indicating model object class path resolution is enabled by default. If that property is not set, the 1582 * {@code true} default is returned.</p> 1583 * 1584 * @return {@code true}, if model object class path resolution is enabled by default; {@code false}, if model object 1585 * class path resolution is disabled by default. 1586 * 1587 * @see #isModelObjectClasspathResolutionEnabled() 1588 * @see #setDefaultModelObjectClasspathResolutionEnabled(java.lang.Boolean) 1589 * 1590 * @since 1.1 1591 */ 1592 public static boolean isDefaultModelObjectClasspathResolutionEnabled() 1593 { 1594 if ( defaultModelObjectClasspathResolutionEnabled == null ) 1595 { 1596 defaultModelObjectClasspathResolutionEnabled = Boolean.valueOf( System.getProperty( 1597 "org.jomc.ri.DefaultObjectManager.defaultModelObjectClasspathResolutionEnabled", 1598 Boolean.toString( true ) ) ); 1599 1600 } 1601 1602 return defaultModelObjectClasspathResolutionEnabled; 1603 } 1604 1605 /** 1606 * Sets the flag indicating model object class path resolution is enabled by default. 1607 * 1608 * @param value The new value of the flag indicating model object class path resolution is enabled by default or 1609 * {@code null}. 1610 * 1611 * @see #isDefaultModelObjectClasspathResolutionEnabled() 1612 * 1613 * @since 1.1 1614 */ 1615 public static void setDefaultModelObjectClasspathResolutionEnabled( final Boolean value ) 1616 { 1617 defaultModelObjectClasspathResolutionEnabled = value; 1618 } 1619 1620 /** 1621 * Gets a flag indicating model object class path resolution is enabled. 1622 * 1623 * @return {@code true}, if model object class path resolution is enabled; {@code false}, if model object class path 1624 * resolution is disabled. 1625 * 1626 * @see #isDefaultModelObjectClasspathResolutionEnabled() 1627 * @see #setModelObjectClasspathResolutionEnabled(java.lang.Boolean) 1628 * 1629 * @since 1.1 1630 */ 1631 public final boolean isModelObjectClasspathResolutionEnabled() 1632 { 1633 if ( this.modelObjectClasspathResolutionEnabled == null ) 1634 { 1635 this.modelObjectClasspathResolutionEnabled = isDefaultModelObjectClasspathResolutionEnabled(); 1636 1637 if ( this.isLoggable( Level.CONFIG ) ) 1638 { 1639 this.log( Level.CONFIG, getDefaultModelObjectClasspahResolutionEnabledInfo( 1640 Locale.getDefault(), Boolean.toString( this.modelObjectClasspathResolutionEnabled ) ), null ); 1641 1642 } 1643 } 1644 1645 return this.modelObjectClasspathResolutionEnabled; 1646 } 1647 1648 /** 1649 * Sets the flag indicating model object class path resolution is enabled. 1650 * 1651 * @param value The new value of the flag indicating model object class path resolution is enabled or {@code null}. 1652 * 1653 * @see #isModelObjectClasspathResolutionEnabled() 1654 * 1655 * @since 1.1 1656 */ 1657 public final void setModelObjectClasspathResolutionEnabled( final Boolean value ) 1658 { 1659 this.modelObjectClasspathResolutionEnabled = value; 1660 } 1661 1662 /** 1663 * Gets a flag indicating model processing is enabled by default. 1664 * <p>The default model processing enabled flag is controlled by system property 1665 * {@code org.jomc.ri.DefaultObjectManager.defaultModelProcessingEnabled} holding a boolean indicating model 1666 * processing is enabled by default. If that property is not set, the {@code true} default is returned.</p> 1667 * 1668 * @return {@code true}, if model processing is enabled by default; {@code false}, if model processing is disabled 1669 * by default. 1670 * 1671 * @see #isModelProcessingEnabled() 1672 * @see #setDefaultModelProcessingEnabled(java.lang.Boolean) 1673 * 1674 * @since 1.1 1675 */ 1676 public static boolean isDefaultModelProcessingEnabled() 1677 { 1678 if ( defaultModelProcessingEnabled == null ) 1679 { 1680 defaultModelProcessingEnabled = Boolean.valueOf( System.getProperty( 1681 "org.jomc.ri.DefaultObjectManager.defaultModelProcessingEnabled", Boolean.toString( true ) ) ); 1682 1683 } 1684 1685 return defaultModelProcessingEnabled; 1686 } 1687 1688 /** 1689 * Sets the flag indicating model processing is enabled by default. 1690 * 1691 * @param value The new value of the flag indicating model processing is enabled by default or {@code null}. 1692 * 1693 * @see #isDefaultModelProcessingEnabled() 1694 * 1695 * @since 1.1 1696 */ 1697 public static void setDefaultModelProcessingEnabled( final Boolean value ) 1698 { 1699 defaultModelProcessingEnabled = value; 1700 } 1701 1702 /** 1703 * Gets a flag indicating model processing is enabled. 1704 * 1705 * @return {@code true}, if model processing is enabled; {@code false}, if model processing is disabled . 1706 * 1707 * @see #isDefaultModelProcessingEnabled() 1708 * @see #setModelProcessingEnabled(java.lang.Boolean) 1709 * 1710 * @since 1.1 1711 */ 1712 public final boolean isModelProcessingEnabled() 1713 { 1714 if ( this.modelProcessingEnabled == null ) 1715 { 1716 this.modelProcessingEnabled = isDefaultModelProcessingEnabled(); 1717 1718 if ( this.isLoggable( Level.CONFIG ) ) 1719 { 1720 this.log( Level.CONFIG, getDefaultModelProcessingEnabledInfo( 1721 Locale.getDefault(), Boolean.toString( this.modelProcessingEnabled ) ), null ); 1722 1723 } 1724 } 1725 1726 return this.modelProcessingEnabled; 1727 } 1728 1729 /** 1730 * Sets the flag indicating model processing is enabled. 1731 * 1732 * @param value The new value of the flag indicating model processing is enabled or {@code null}. 1733 * 1734 * @see #isModelProcessingEnabled() 1735 * 1736 * @since 1.1 1737 */ 1738 public final void setModelProcessingEnabled( final Boolean value ) 1739 { 1740 this.modelProcessingEnabled = value; 1741 } 1742 1743 /** 1744 * Gets the name of the platform's bootstrap class loader class. 1745 * <p>The name of the platform's bootstrap class loader class is controlled by system property 1746 * {@code org.jomc.ri.DefaultObjectManager.bootstrapClassLoaderClassName} holding the name of the platform's 1747 * bootstrap class loader class. If that property is not set, the bootstrap class loader is assumed to be 1748 * represented by a {@code null} parent class loader.</p> 1749 * 1750 * @return The name of the platform's bootstrap class loader class or {@code null}. 1751 * 1752 * @see #getClassLoader(java.lang.ClassLoader) 1753 */ 1754 public static String getBootstrapClassLoaderClassName() 1755 { 1756 if ( bootstrapClassLoaderClassName == null && !bootstrapClassLoaderClassNameInitialized ) 1757 { 1758 bootstrapClassLoaderClassName = 1759 System.getProperty( "org.jomc.ri.DefaultObjectManager.bootstrapClassLoaderClassName" ); 1760 1761 bootstrapClassLoaderClassNameInitialized = true; 1762 } 1763 1764 return bootstrapClassLoaderClassName; 1765 } 1766 1767 /** 1768 * Sets the name of the platform's bootstrap class loader class. 1769 * 1770 * @param value The new name of the platform's bootstrap class loader class or {@code null}. 1771 * 1772 * @see #getBootstrapClassLoaderClassName() 1773 */ 1774 public static void setBootstrapClassLoaderClassName( final String value ) 1775 { 1776 bootstrapClassLoaderClassName = value; 1777 bootstrapClassLoaderClassNameInitialized = false; 1778 } 1779 1780 /** 1781 * Gets the modules registered with a given class loader. 1782 * 1783 * @param classLoader The class loader to get the modules of. 1784 * 1785 * @return The modules of the given class loader. 1786 * 1787 * @throws NullPointerException if {@code classLoader} is {@code null}. 1788 * @throws ObjectManagementException if getting the modules fails. 1789 * 1790 * @see #getDefaultModules() 1791 * @see #getModelIdentifier() 1792 * @see #isModelObjectClasspathResolutionEnabled() 1793 * @see #isModelProcessingEnabled() 1794 * @see #getRuntimeModules(org.jomc.model.Modules, java.util.Map) 1795 */ 1796 public Modules getModules( final ClassLoader classLoader ) 1797 { 1798 if ( classLoader == null ) 1799 { 1800 throw new NullPointerException( "classLoader" ); 1801 } 1802 1803 synchronized ( this.modules ) 1804 { 1805 Modules cachedModules = this.modules.get( classLoader ); 1806 1807 if ( cachedModules == null ) 1808 { 1809 final List<LogRecord> logRecords = new ArrayList<LogRecord>( 1024 ); 1810 1811 try 1812 { 1813 final ModelContext modelContext = ModelContextFactory.newInstance().newModelContext( classLoader ); 1814 1815 logRecords.add( new LogRecord( Level.FINER, getCreatingModulesInfo( 1816 Locale.getDefault(), this.getClassLoaderInfo( classLoader, null ) ) ) ); 1817 1818 modelContext.setLogLevel( this.getLogLevel() ); 1819 modelContext.getListeners().add( new ModelContext.Listener() 1820 { 1821 1822 @Override 1823 public void onLog( final Level level, final String message, final Throwable t ) 1824 { 1825 super.onLog( level, message, t ); 1826 final LogRecord r = new LogRecord( level, message ); 1827 r.setThrown( t ); 1828 1829 logRecords.add( r ); 1830 } 1831 1832 } ); 1833 1834 Model model = modelContext.findModel( this.getModelIdentifier() ); 1835 cachedModules = ModelHelper.getModules( model ); 1836 1837 if ( cachedModules != null ) 1838 { 1839 if ( this.isModelObjectClasspathResolutionEnabled() ) 1840 { 1841 final Module classpathModule = cachedModules.getClasspathModule( 1842 Modules.getDefaultClasspathModuleName(), classLoader ); 1843 1844 if ( classpathModule != null ) 1845 { 1846 cachedModules.getModule().add( classpathModule ); 1847 } 1848 } 1849 1850 if ( this.isModelProcessingEnabled() ) 1851 { 1852 model = modelContext.processModel( model ); 1853 } 1854 1855 final ModelValidationReport validationReport = modelContext.validateModel( model ); 1856 1857 for ( ModelValidationReport.Detail d : validationReport.getDetails() ) 1858 { 1859 final LogRecord r = new LogRecord( d.getLevel(), d.getMessage() ); 1860 logRecords.add( r ); 1861 } 1862 1863 cachedModules = validationReport.isModelValid() ? ModelHelper.getModules( model ) : null; 1864 } 1865 } 1866 catch ( final ModelException e ) 1867 { 1868 cachedModules = null; 1869 1870 final LogRecord r = new LogRecord( Level.SEVERE, getMessage( e ) ); 1871 r.setThrown( e ); 1872 logRecords.add( r ); 1873 } 1874 1875 if ( cachedModules == null ) 1876 { 1877 cachedModules = this.getDefaultModules(); 1878 1879 logRecords.add( new LogRecord( Level.WARNING, getDefaultModulesWarning( 1880 Locale.getDefault(), this.getModelIdentifier(), 1881 this.getClassLoaderInfo( classLoader, null ) ) ) ); 1882 1883 } 1884 1885 final ClassLoader objectsLoader = this.getDefaultClassLoader( classLoader ); 1886 1887 synchronized ( this.objects ) 1888 { 1889 Map<Object, Instance> objectMap = this.objects.get( objectsLoader ); 1890 if ( objectMap == null ) 1891 { 1892 objectMap = new WeakIdentityHashMap<Object, Instance>(); 1893 this.objects.put( objectsLoader, objectMap ); 1894 } 1895 1896 cachedModules = this.getRuntimeModules( cachedModules, objectMap ); 1897 1898 if ( cachedModules instanceof RuntimeModelObject ) 1899 { 1900 ( (RuntimeModelObject) cachedModules ).clear(); 1901 } 1902 } 1903 1904 this.modules.put( classLoader, cachedModules ); 1905 1906 for ( LogRecord r : logRecords ) 1907 { 1908 this.log( classLoader, r.getLevel(), r.getMessage(), r.getThrown() ); 1909 } 1910 1911 if ( this.isLoggable( Level.FINEST ) ) 1912 { 1913 this.logModulesReport( cachedModules, classLoader ); 1914 } 1915 } 1916 1917 return cachedModules; 1918 } 1919 } 1920 1921 /** 1922 * Gets a new default modules instance. 1923 * 1924 * @return A new default modules instance. 1925 * 1926 * @throws ObjectManagementException if getting a new default modules instance fails. 1927 * 1928 * @see #getModules(java.lang.ClassLoader) 1929 * 1930 * @since 1.1 1931 */ 1932 public Modules getDefaultModules() 1933 { 1934 final Modules defaultModules = new Modules(); 1935 final Module defaultModule = new Module(); 1936 defaultModule.setSpecifications( new Specifications() ); 1937 defaultModule.setImplementations( new Implementations() ); 1938 defaultModules.getModule().add( defaultModule ); 1939 defaultModule.setName( getDefaultModuleName( Locale.getDefault() ) ); 1940 1941 defaultModule.getSpecifications().getSpecification().add( createDefaultSpecification( 1942 ObjectManager.class, Multiplicity.ONE, SINGLETON_SCOPE_IDENTIFIER ) ); 1943 1944 defaultModule.getSpecifications().getSpecification().add( createDefaultSpecification( 1945 Scope.class, null, null ) ); 1946 1947 defaultModule.getSpecifications().getSpecification().add( createDefaultSpecification( 1948 Listener.class, null, null ) ); 1949 1950 defaultModule.getSpecifications().getSpecification().add( createDefaultSpecification( 1951 Locator.class, null, null ) ); 1952 1953 defaultModule.getSpecifications().getSpecification().add( createDefaultSpecification( 1954 Invoker.class, null, null ) ); 1955 1956 defaultModule.getSpecifications().getSpecification().add( createDefaultSpecification( 1957 Invocation.class, Multiplicity.ONE, null ) ); 1958 1959 defaultModule.getImplementations().getImplementation().add( createDefaultImplementation( 1960 ObjectManagerFactory.class, getDefaultImplementationName( Locale.getDefault() ) ) ); 1961 1962 defaultModule.getImplementations().getImplementation().add( createDefaultImplementation( 1963 ObjectManagementException.class, getDefaultImplementationName( Locale.getDefault() ) ) ); 1964 1965 defaultModule.getImplementations().getImplementation().add( createDefaultImplementation( 1966 DefaultInvocation.class, getDefaultImplementationName( Locale.getDefault() ) ) ); 1967 1968 defaultModule.getImplementations().getImplementation().add( createDefaultImplementation( 1969 DefaultInvoker.class, getDefaultImplementationName( Locale.getDefault() ) ) ); 1970 1971 defaultModule.getImplementations().getImplementation().add( createDefaultImplementation( 1972 DefaultListener.class, getDefaultImplementationName( Locale.getDefault() ) ) ); 1973 1974 defaultModule.getImplementations().getImplementation().add( createDefaultImplementation( 1975 DefaultLocator.class, getDefaultImplementationName( Locale.getDefault() ) ) ); 1976 1977 defaultModule.getImplementations().getImplementation().add( createDefaultImplementation( 1978 DefaultScope.class, getDefaultImplementationName( Locale.getDefault() ) ) ); 1979 1980 final Implementation defaultObjectManager = createDefaultImplementation( 1981 DefaultObjectManager.class, getDefaultImplementationName( Locale.getDefault() ) ); 1982 1983 defaultObjectManager.setSpecifications( new Specifications() ); 1984 1985 final SpecificationReference refObjectManager = new SpecificationReference(); 1986 refObjectManager.setIdentifier( ObjectManager.class.getName() ); 1987 refObjectManager.setVersion( getDefaultModulesVersion( Locale.getDefault() ) ); 1988 defaultObjectManager.getSpecifications().getReference().add( refObjectManager ); 1989 1990 defaultModule.getImplementations().getImplementation().add( defaultObjectManager ); 1991 return defaultModules; 1992 } 1993 1994 /** 1995 * Gets a new {@code Modules} instance to register with a class loader. 1996 * 1997 * @param modules The modules prepared for registration with a class loader. 1998 * @param objectMap The object map to associate with the given modules. 1999 * 2000 * @return The instance to register with a class loader. 2001 * 2002 * @throws NullPointerException if {@code modules} or {@code objectMap} is {@code null}. 2003 * 2004 * @see #getModules(java.lang.ClassLoader) 2005 * @see RuntimeModules 2006 * 2007 * @since 1.2 2008 */ 2009 public Modules getRuntimeModules( final Modules modules, final Map<Object, Instance> objectMap ) 2010 { 2011 if ( modules == null ) 2012 { 2013 throw new NullPointerException( "modules" ); 2014 } 2015 if ( objectMap == null ) 2016 { 2017 throw new NullPointerException( "objectMap" ); 2018 } 2019 2020 return new RuntimeModules( modules, objectMap ); 2021 } 2022 2023 /** 2024 * Gets the class loader of a given class. 2025 * 2026 * @param clazz The class whose class loader to get. 2027 * 2028 * @return The class loader of {@code clazz}. 2029 * 2030 * @throws NullPointerException if {@code clazz} is {@code null}. 2031 * 2032 * @since 1.1 2033 */ 2034 public ClassLoader getDefaultClassLoader( final Class<?> clazz ) 2035 { 2036 if ( clazz == null ) 2037 { 2038 throw new NullPointerException( "clazz" ); 2039 } 2040 2041 ClassLoader cl = clazz.getClassLoader(); 2042 if ( cl == null ) 2043 { 2044 cl = BOOTSTRAP_CLASSLOADER; 2045 } 2046 2047 return cl; 2048 } 2049 2050 /** 2051 * Gets the parent class loader of a given class loader recursively. 2052 * <p>This method recursively finds the parent class loader of the given class loader. Recursion stops at the 2053 * platform's bootstrap class loader. That class loader is detected when either the current class loader has no 2054 * parent (a call to the {@code getParent()} method returns {@code null}) or when the class name of the 2055 * current class loader's parent class loader is equal to the name returned by method 2056 * {@code getBootstrapClassLoaderClassName()}. Configuration of the name of the platform's bootstrap class loader 2057 * class is needed when the platform's {@code getParent()} method of the {@code ClassLoader} class does not return 2058 * {@code null} to indicate the bootstrap class loader but instead returns an instance of {@code ClassLoader}.</p> 2059 * 2060 * @param classLoader The class loader whose parent class loader to return or {@code null} to return a 2061 * {@code ClassLoader} instance representing the platform's bootstrap class loader. 2062 * 2063 * @return The parent class loader of {@code classLoader}. 2064 * 2065 * @throws NullPointerException if {@code classLoader} is {@code null}. 2066 * 2067 * @see #getBootstrapClassLoaderClassName() 2068 * @see ClassLoader#getParent() 2069 * 2070 * @since 1.1 2071 */ 2072 public ClassLoader getDefaultClassLoader( final ClassLoader classLoader ) 2073 { 2074 if ( classLoader == null ) 2075 { 2076 return BOOTSTRAP_CLASSLOADER; 2077 } 2078 2079 synchronized ( defaultClassLoaders ) 2080 { 2081 ClassLoader loader = null; 2082 Reference<ClassLoader> reference = defaultClassLoaders.get( classLoader ); 2083 2084 if ( reference != null ) 2085 { 2086 loader = reference.get(); 2087 } 2088 2089 if ( loader == null ) 2090 { 2091 if ( classLoader.getParent() != null 2092 && !classLoader.getParent().getClass().getName().equals( getBootstrapClassLoaderClassName() ) ) 2093 { 2094 loader = this.getDefaultClassLoader( classLoader.getParent() ); 2095 } 2096 else 2097 { 2098 loader = classLoader; 2099 } 2100 2101 defaultClassLoaders.put( classLoader, new WeakReference<ClassLoader>( loader ) ); 2102 } 2103 2104 return loader; 2105 } 2106 } 2107 2108 /** 2109 * Gets the class loader of a given class. 2110 * 2111 * @param clazz The class whose class loader to return. 2112 * 2113 * @return The class loader of {@code clazz}. 2114 * 2115 * @throws NullPointerException if {@code clazz} is {@code null}. 2116 * 2117 * @deprecated As of JOMC 1.1, please use method {@link #getDefaultClassLoader(java.lang.Class)}. This method will 2118 * be removed in version 2.0. 2119 */ 2120 @Deprecated 2121 public static ClassLoader getClassLoader( final Class<?> clazz ) 2122 { 2123 if ( clazz == null ) 2124 { 2125 throw new NullPointerException( "clazz" ); 2126 } 2127 2128 ClassLoader cl = clazz.getClassLoader(); 2129 if ( cl == null ) 2130 { 2131 cl = BOOTSTRAP_CLASSLOADER; 2132 } 2133 2134 return cl; 2135 } 2136 2137 /** 2138 * Gets the parent class loader of a given class loader recursively. 2139 * <p>This method recursively finds the parent class loader of the given class loader. Recursion stops at the 2140 * platform's bootstrap class loader. That class loader is detected when either the current class loader has no 2141 * parent (a call to the {@code getParent()} method returns {@code null}) or when the class name of the 2142 * current class loader's parent class loader is equal to the name returned by method 2143 * {@code getBootstrapClassLoaderClassName()}. Configuration of the name of the platform's bootstrap class loader 2144 * class is needed when the platform's {@code getParent()} method of the {@code ClassLoader} class does not return 2145 * {@code null} to indicate the bootstrap class loader but instead returns an instance of {@code ClassLoader}.</p> 2146 * 2147 * @param classLoader The class loader whose parent class loader to return or {@code null} to return a 2148 * {@code ClassLoader} instance representing the platform's bootstrap class loader. 2149 * 2150 * @return The parent class loader of {@code classLoader}. 2151 * 2152 * @throws NullPointerException if {@code classLoader} is {@code null}. 2153 * 2154 * @see #getBootstrapClassLoaderClassName() 2155 * @see ClassLoader#getParent() 2156 * 2157 * @deprecated As of JOMC 1.1, please use method {@link #getDefaultClassLoader(java.lang.ClassLoader)}. This method 2158 * will be removed in version 2.0. 2159 */ 2160 @Deprecated 2161 public static ClassLoader getClassLoader( final ClassLoader classLoader ) 2162 { 2163 if ( classLoader == null ) 2164 { 2165 return BOOTSTRAP_CLASSLOADER; 2166 } 2167 2168 synchronized ( defaultClassLoaders ) 2169 { 2170 ClassLoader loader = null; 2171 Reference<ClassLoader> reference = defaultClassLoaders.get( classLoader ); 2172 2173 if ( reference != null ) 2174 { 2175 loader = reference.get(); 2176 } 2177 2178 if ( loader == null ) 2179 { 2180 if ( classLoader.getParent() != null 2181 && !classLoader.getParent().getClass().getName().equals( getBootstrapClassLoaderClassName() ) ) 2182 { 2183 loader = getClassLoader( classLoader.getParent() ); 2184 } 2185 else 2186 { 2187 loader = classLoader; 2188 } 2189 2190 defaultClassLoaders.put( classLoader, new WeakReference<ClassLoader>( loader ) ); 2191 } 2192 2193 return loader; 2194 } 2195 } 2196 2197 /** 2198 * Gets an object of a given instance from a given scope. 2199 * 2200 * @param scope The scope to get the object from or {@code null}. 2201 * @param instance The instance of the object to get. 2202 * @param classLoader The class loader to use for creating the object. 2203 * 2204 * @return An object of {@code instance} from {@code scope} or {@code null}, if no such object is found. 2205 * 2206 * @throws NullPointerException if {@code instance} or {@code classLoader} is {@code null}. 2207 * @throws ObjectManagementException if getting an object fails. 2208 */ 2209 public Object getObject( final Scope scope, final Instance instance, final ClassLoader classLoader ) 2210 { 2211 if ( instance == null ) 2212 { 2213 throw new NullPointerException( "instance" ); 2214 } 2215 if ( classLoader == null ) 2216 { 2217 throw new NullPointerException( "classLoader" ); 2218 } 2219 2220 try 2221 { 2222 Object object = null; 2223 2224 if ( scope != null ) 2225 { 2226 synchronized ( instance ) 2227 { 2228 boolean created = true; 2229 2230 synchronized ( scope ) 2231 { 2232 object = scope.getObject( instance.getIdentifier() ); 2233 2234 if ( object == null ) 2235 { 2236 scope.putObject( instance.getIdentifier(), instance ); 2237 created = false; 2238 } 2239 } 2240 2241 if ( object instanceof Instance ) 2242 { 2243 synchronized ( object ) 2244 { 2245 synchronized ( scope ) 2246 { 2247 object = scope.getObject( instance.getIdentifier() ); 2248 2249 if ( object instanceof Instance ) 2250 { 2251 throw new ObjectManagementException( getDependencyCycleMessage( 2252 Locale.getDefault(), instance.getIdentifier() ) ); 2253 2254 } 2255 } 2256 } 2257 } 2258 2259 if ( !created ) 2260 { 2261 try 2262 { 2263 object = this.getModules( classLoader ).createObject( instance, classLoader ); 2264 2265 if ( object != null ) 2266 { 2267 object = this.createProxy( instance, object, classLoader ); 2268 } 2269 2270 created = true; 2271 } 2272 finally 2273 { 2274 synchronized ( scope ) 2275 { 2276 if ( created && object != null ) 2277 { 2278 final Object o = scope.putObject( instance.getIdentifier(), object ); 2279 2280 if ( o != instance ) 2281 { 2282 scope.putObject( instance.getIdentifier(), o ); 2283 throw new AssertionError( getScopeContentionFailure( 2284 Locale.getDefault(), instance.getIdentifier() ) ); 2285 2286 } 2287 } 2288 else 2289 { 2290 scope.removeObject( instance.getIdentifier() ); 2291 } 2292 } 2293 } 2294 } 2295 } 2296 } 2297 else 2298 { 2299 object = this.getModules( classLoader ).createObject( instance, classLoader ); 2300 2301 if ( object != null ) 2302 { 2303 object = this.createProxy( instance, object, classLoader ); 2304 } 2305 } 2306 2307 return object; 2308 } 2309 catch ( final ModelObjectException e ) 2310 { 2311 throw new ObjectManagementException( getMessage( e ), e ); 2312 } 2313 catch ( final InstantiationException e ) 2314 { 2315 throw new ObjectManagementException( getMessage( e ), e ); 2316 } 2317 } 2318 2319 /** 2320 * Gets an object for a given location URI. 2321 * 2322 * @param specification The specification class of the object to locate. 2323 * @param location The location URI of the object to locate. 2324 * @param classLoader The class loader to use for loading locator classes. 2325 * @param <T> The type of the object. 2326 * 2327 * @return An object located at {@code location} or {@code null}, if no such object is found. 2328 * 2329 * @throws NullPointerException if {@code specification}, {@code location} or {@code classLoader} is {@code null}. 2330 * @throws ObjectManagementException if getting an object fails. 2331 */ 2332 public <T> T getObject( final Class<T> specification, final URI location, final ClassLoader classLoader ) 2333 { 2334 if ( specification == null ) 2335 { 2336 throw new NullPointerException( "specification" ); 2337 } 2338 if ( location == null ) 2339 { 2340 throw new NullPointerException( "location" ); 2341 } 2342 if ( classLoader == null ) 2343 { 2344 throw new NullPointerException( "classLoader" ); 2345 } 2346 2347 try 2348 { 2349 T object = null; 2350 final Locator locator = this.getLocator( location, classLoader ); 2351 2352 if ( locator != null ) 2353 { 2354 object = locator.getObject( specification, location ); 2355 } 2356 else if ( this.isLoggable( Level.WARNING ) ) 2357 { 2358 this.log( classLoader, Level.WARNING, getMissingLocatorMessage( 2359 Locale.getDefault(), location.getScheme() ), null ); 2360 2361 } 2362 2363 return object; 2364 } 2365 catch ( final IOException e ) 2366 { 2367 throw new ObjectManagementException( getMessage( e ), e ); 2368 } 2369 } 2370 2371 /** 2372 * Gets the scope implementation for a given scope identifier registered with a given class loader. 2373 * 2374 * @param identifier The identifier of the scope to get an implementation of. 2375 * @param classLoader The class loader to use for loading scope implementations. 2376 * 2377 * @return The implementation of the scope identified by {@code identifier} or {@code null}, if no such scope 2378 * implementation is found. 2379 * 2380 * @throws NullPointerException if {@code classLoader} or {@code identifier} is {@code null}. 2381 * @throws ObjectManagementException if getting the scope implementation fails. 2382 * 2383 * @see #getDefaultScope(org.jomc.model.Modules, java.lang.String) 2384 */ 2385 public Scope getScope( final String identifier, final ClassLoader classLoader ) 2386 { 2387 if ( classLoader == null ) 2388 { 2389 throw new NullPointerException( "classLoader" ); 2390 } 2391 if ( identifier == null ) 2392 { 2393 throw new NullPointerException( "identifier" ); 2394 } 2395 2396 try 2397 { 2398 final ClassLoader scopesLoader = this.getDefaultClassLoader( classLoader ); 2399 2400 synchronized ( this.scopes ) 2401 { 2402 Map<String, Scope> cachedScopes = this.scopes.get( scopesLoader ); 2403 if ( cachedScopes == null ) 2404 { 2405 cachedScopes = new HashMap<String, Scope>(); 2406 this.scopes.put( scopesLoader, cachedScopes ); 2407 } 2408 2409 Scope scope = cachedScopes.get( identifier ); 2410 2411 if ( scope == null ) 2412 { 2413 // Bootstrap scope loading. 2414 final Modules model = this.getModules( classLoader ); 2415 final Specification scopeSpecification = model.getSpecification( Scope.class ); 2416 2417 if ( scopeSpecification != null ) 2418 { 2419 final Implementations implementations = 2420 model.getImplementations( scopeSpecification.getIdentifier() ); 2421 2422 if ( implementations != null ) 2423 { 2424 for ( int i = 0, s0 = implementations.getImplementation().size(); i < s0; i++ ) 2425 { 2426 final Implementation impl = implementations.getImplementation().get( i ); 2427 2428 if ( identifier.equals( impl.getName() ) ) 2429 { 2430 final Instance instance = model.getInstance( impl.getIdentifier() ); 2431 2432 if ( instance != null ) 2433 { 2434 scope = (Scope) model.createObject( instance, classLoader ); 2435 cachedScopes.put( identifier, scope ); 2436 if ( this.isLoggable( Level.CONFIG ) ) 2437 { 2438 this.log( classLoader, Level.CONFIG, getScopeInfoMessage( 2439 Locale.getDefault(), impl.getIdentifier(), identifier, 2440 this.getClassLoaderInfo( classLoader, scopesLoader ) ), null ); 2441 2442 } 2443 break; 2444 } 2445 else if ( this.isLoggable( Level.WARNING ) ) 2446 { 2447 this.log( classLoader, Level.WARNING, getMissingInstanceMessage( 2448 Locale.getDefault(), impl.getIdentifier(), impl.getName() ), null ); 2449 2450 } 2451 } 2452 } 2453 } 2454 } 2455 else if ( this.isLoggable( Level.WARNING ) ) 2456 { 2457 this.log( classLoader, Level.WARNING, getMissingSpecificationMessage( 2458 Locale.getDefault(), Scope.class.getName() ), null ); 2459 2460 } 2461 2462 if ( scope == null ) 2463 { 2464 scope = this.getDefaultScope( model, identifier ); 2465 if ( scope != null ) 2466 { 2467 cachedScopes.put( identifier, scope ); 2468 if ( this.isLoggable( Level.CONFIG ) ) 2469 { 2470 this.log( classLoader, Level.CONFIG, getDefaultScopeInfoMessage( 2471 Locale.getDefault(), identifier, 2472 this.getClassLoaderInfo( classLoader, scopesLoader ) ), null ); 2473 2474 } 2475 } 2476 } 2477 } 2478 2479 return scope; 2480 } 2481 } 2482 catch ( final ModelObjectException e ) 2483 { 2484 throw new ObjectManagementException( getMessage( e ), e ); 2485 } 2486 catch ( final InstantiationException e ) 2487 { 2488 throw new ObjectManagementException( getMessage( e ), e ); 2489 } 2490 } 2491 2492 /** 2493 * Gets a new default scope implementation instance for a given identifier. 2494 * 2495 * @param identifier The identifier to get a new default scope implementation instance for. 2496 * 2497 * @return A new default scope implementation instance for {@code identifier} or {@code null}, if no such instance 2498 * is available. 2499 * 2500 * @throws NullPointerException if {@code identifier} is {@code null}. 2501 * 2502 * @see #getScope(java.lang.String, java.lang.ClassLoader) 2503 * 2504 * @deprecated As of JOMC 1.2, replaced by method {@link #getDefaultScope(org.jomc.model.Modules,java.lang.String)}. 2505 * This method will be removed in version 2.0. 2506 */ 2507 @Deprecated 2508 public Scope getDefaultScope( final String identifier ) 2509 { 2510 if ( identifier == null ) 2511 { 2512 throw new NullPointerException( "identifier" ); 2513 } 2514 2515 DefaultScope defaultScope = null; 2516 2517 if ( identifier.equals( SINGLETON_SCOPE_IDENTIFIER ) ) 2518 { 2519 defaultScope = new DefaultScope( new HashMap<String, Object>() ); 2520 } 2521 2522 return defaultScope; 2523 } 2524 2525 /** 2526 * Gets a new default scope implementation instance for a given identifier. 2527 * 2528 * @param model The model to get a new default scope implementation instance of. 2529 * @param identifier The identifier to get a new default scope implementation instance for. 2530 * 2531 * @return A new default scope implementation instance for {@code identifier} or {@code null}, if no such instance 2532 * is available. 2533 * 2534 * @throws NullPointerException if {@code model} or {@code identifier} is {@code null}. 2535 * @throws ObjectManagementException if getting a new default scope implementation instance fails. 2536 * 2537 * @see #getScope(java.lang.String, java.lang.ClassLoader) 2538 */ 2539 public Scope getDefaultScope( final Modules model, final String identifier ) 2540 { 2541 if ( model == null ) 2542 { 2543 throw new NullPointerException( "model" ); 2544 } 2545 if ( identifier == null ) 2546 { 2547 throw new NullPointerException( "identifier" ); 2548 } 2549 2550 try 2551 { 2552 Scope defaultScope = null; 2553 2554 if ( identifier.equals( SINGLETON_SCOPE_IDENTIFIER ) ) 2555 { 2556 defaultScope = new DefaultScope( new HashMap<String, Object>() ); 2557 model.getInstance( defaultScope ); 2558 } 2559 2560 return defaultScope; 2561 } 2562 catch ( final ModelObjectException e ) 2563 { 2564 throw new ObjectManagementException( getMessage( e ), e ); 2565 } 2566 } 2567 2568 /** 2569 * Gets a locator to use with a given location URI registered with a given class loader. 2570 * 2571 * @param location The location URI to get a locator for. 2572 * @param classLoader The class loader to use for loading locator implementations. 2573 * 2574 * @return The locator to use for locating objects at {@code location} or {@code null}, if no such locator is 2575 * available. 2576 * 2577 * @throws NullPointerException if {@code classLoader} or {@code location} is {@code null}. 2578 * @throws ObjectManagementException if getting a locator fails. 2579 * 2580 * @see #getDefaultLocator(org.jomc.model.Modules, java.net.URI) 2581 */ 2582 public Locator getLocator( final URI location, final ClassLoader classLoader ) 2583 { 2584 if ( classLoader == null ) 2585 { 2586 throw new NullPointerException( "classLoader" ); 2587 } 2588 if ( location == null ) 2589 { 2590 throw new NullPointerException( "location" ); 2591 } 2592 2593 try 2594 { 2595 final String scheme = location.getScheme(); 2596 2597 if ( scheme != null ) 2598 { 2599 final ClassLoader locatorsLoader = this.getDefaultClassLoader( classLoader ); 2600 2601 synchronized ( this.locators ) 2602 { 2603 Map<String, Locator> cachedLocators = this.locators.get( locatorsLoader ); 2604 if ( cachedLocators == null ) 2605 { 2606 cachedLocators = new HashMap<String, Locator>(); 2607 this.locators.put( locatorsLoader, cachedLocators ); 2608 } 2609 2610 Locator locator = cachedLocators.get( scheme ); 2611 2612 if ( locator == null ) 2613 { 2614 // Bootstrap locator loading. 2615 final Modules model = this.getModules( classLoader ); 2616 final Specification locatorSpecification = model.getSpecification( Locator.class ); 2617 2618 if ( locatorSpecification != null ) 2619 { 2620 final Implementations implementations = 2621 model.getImplementations( locatorSpecification.getIdentifier() ); 2622 2623 if ( implementations != null ) 2624 { 2625 for ( int i = 0, s0 = implementations.getImplementation().size(); i < s0; i++ ) 2626 { 2627 final Implementation impl = implementations.getImplementation().get( i ); 2628 2629 if ( scheme.equals( impl.getName() ) ) 2630 { 2631 final Instance instance = model.getInstance( impl.getIdentifier() ); 2632 2633 if ( instance != null ) 2634 { 2635 locator = (Locator) model.createObject( instance, classLoader ); 2636 cachedLocators.put( scheme, locator ); 2637 2638 if ( this.isLoggable( Level.CONFIG ) ) 2639 { 2640 this.log( classLoader, Level.CONFIG, getLocatorInfoMessage( 2641 Locale.getDefault(), impl.getIdentifier(), scheme, 2642 this.getClassLoaderInfo( classLoader, locatorsLoader ) ), null ); 2643 2644 } 2645 2646 break; 2647 } 2648 else if ( this.isLoggable( Level.WARNING ) ) 2649 { 2650 this.log( classLoader, Level.WARNING, getMissingInstanceMessage( 2651 Locale.getDefault(), impl.getIdentifier(), impl.getName() ), null ); 2652 2653 } 2654 } 2655 } 2656 } 2657 } 2658 else if ( this.isLoggable( Level.WARNING ) ) 2659 { 2660 this.log( classLoader, Level.WARNING, getMissingSpecificationMessage( 2661 Locale.getDefault(), Locator.class.getName() ), null ); 2662 2663 } 2664 2665 if ( locator == null ) 2666 { 2667 locator = this.getDefaultLocator( model, location ); 2668 if ( locator != null ) 2669 { 2670 cachedLocators.put( scheme, locator ); 2671 if ( this.isLoggable( Level.CONFIG ) ) 2672 { 2673 this.log( classLoader, Level.CONFIG, getDefaultLocatorInfoMessage( 2674 Locale.getDefault(), scheme, 2675 this.getClassLoaderInfo( classLoader, locatorsLoader ) ), null ); 2676 2677 } 2678 } 2679 } 2680 } 2681 2682 return locator; 2683 } 2684 } 2685 2686 return null; 2687 } 2688 catch ( final ModelObjectException e ) 2689 { 2690 throw new ObjectManagementException( getMessage( e ), e ); 2691 } 2692 catch ( final InstantiationException e ) 2693 { 2694 throw new ObjectManagementException( getMessage( e ), e ); 2695 } 2696 } 2697 2698 /** 2699 * Gets a new default locator implementation instance for a given location URI. 2700 * 2701 * @param location The location URI to get a new default locator implementation instance for. 2702 * 2703 * @return A new default locator implementation instance for {@code location} or {@code null}, if no such instance 2704 * is available. 2705 * 2706 * @throws NullPointerException if {@code location} is {@code null}. 2707 * 2708 * @see #getLocator(java.net.URI, java.lang.ClassLoader) 2709 * 2710 * @deprecated As of JOMC 1.2, replaced by method {@link #getDefaultLocator(org.jomc.model.Modules, java.net.URI)}. 2711 * This method will be removed in version 2.0. 2712 */ 2713 @Deprecated 2714 public Locator getDefaultLocator( final URI location ) 2715 { 2716 if ( location == null ) 2717 { 2718 throw new NullPointerException( "location" ); 2719 } 2720 2721 Locator locator = null; 2722 final DefaultLocator defaultLocator = new DefaultLocator(); 2723 2724 if ( defaultLocator.isLocationSupported( location ) ) 2725 { 2726 locator = defaultLocator; 2727 } 2728 2729 return locator; 2730 } 2731 2732 /** 2733 * Gets a new default locator implementation instance for a given location URI. 2734 * 2735 * @param model The model to get a new default location implementation instance of. 2736 * @param location The location URI to get a new default locator implementation instance for. 2737 * 2738 * @return A new default locator implementation instance for {@code location} or {@code null}, if no such instance 2739 * is available. 2740 * 2741 * @throws NullPointerException if {@code model} or {@code location} is {@code null}. 2742 * @throws ObjectManagementException if getting a new default locator implementation instance fails. 2743 * 2744 * @see #getLocator(java.net.URI, java.lang.ClassLoader) 2745 * 2746 * @since 1.2 2747 */ 2748 public Locator getDefaultLocator( final Modules model, final URI location ) 2749 { 2750 if ( model == null ) 2751 { 2752 throw new NullPointerException( "model" ); 2753 } 2754 if ( location == null ) 2755 { 2756 throw new NullPointerException( "location" ); 2757 } 2758 2759 try 2760 { 2761 Locator locator = null; 2762 final DefaultLocator defaultLocator = new DefaultLocator(); 2763 2764 if ( defaultLocator.isLocationSupported( location ) ) 2765 { 2766 locator = defaultLocator; 2767 model.getInstance( locator ); 2768 } 2769 2770 return locator; 2771 } 2772 catch ( final ModelObjectException e ) 2773 { 2774 throw new ObjectManagementException( getMessage( e ), e ); 2775 } 2776 } 2777 2778 /** 2779 * Gets the invoker registered with a given class loader. 2780 * 2781 * @param classLoader The class loader to use for loading invoker implementations. 2782 * 2783 * @return The invoker of the given class loader. 2784 * 2785 * @throws NullPointerException if {@code classLoader} is {@code null}. 2786 * @throws ObjectManagementException if getting the invoker fails. 2787 * 2788 * @see #getDefaultInvoker(org.jomc.model.Modules) 2789 */ 2790 public Invoker getInvoker( final ClassLoader classLoader ) 2791 { 2792 if ( classLoader == null ) 2793 { 2794 throw new NullPointerException( "classLoader" ); 2795 } 2796 2797 try 2798 { 2799 final ClassLoader invokersLoader = this.getDefaultClassLoader( classLoader ); 2800 2801 synchronized ( this.invokers ) 2802 { 2803 Invoker invoker = this.invokers.get( invokersLoader ); 2804 2805 if ( invoker == null ) 2806 { 2807 final Modules model = this.getModules( classLoader ); 2808 final Specification invokerSpecification = model.getSpecification( Invoker.class ); 2809 2810 if ( invokerSpecification != null ) 2811 { 2812 final Implementations implementations = 2813 model.getImplementations( invokerSpecification.getIdentifier() ); 2814 2815 if ( implementations != null && !implementations.getImplementation().isEmpty() ) 2816 { 2817 for ( int i = 0, s0 = implementations.getImplementation().size(); i < s0; i++ ) 2818 { 2819 final Implementation impl = implementations.getImplementation().get( i ); 2820 2821 if ( invoker == null ) 2822 { 2823 final Instance invokerInstance = model.getInstance( impl.getIdentifier() ); 2824 2825 if ( invokerInstance != null ) 2826 { 2827 invoker = (Invoker) model.createObject( invokerInstance, classLoader ); 2828 this.invokers.put( invokersLoader, invoker ); 2829 2830 if ( this.isLoggable( Level.CONFIG ) ) 2831 { 2832 this.log( classLoader, Level.CONFIG, getInvokerInfoMessage( 2833 Locale.getDefault(), impl.getIdentifier(), 2834 this.getClassLoaderInfo( classLoader, invokersLoader ) ), null ); 2835 2836 } 2837 } 2838 else if ( this.isLoggable( Level.WARNING ) ) 2839 { 2840 this.log( classLoader, Level.WARNING, getMissingInstanceMessage( 2841 Locale.getDefault(), impl.getIdentifier(), impl.getName() ), null ); 2842 2843 } 2844 } 2845 else if ( this.isLoggable( Level.CONFIG ) ) 2846 { 2847 this.log( classLoader, Level.CONFIG, getIgnoredInvokerMessage( 2848 Locale.getDefault(), impl.getIdentifier() ), null ); 2849 2850 } 2851 } 2852 } 2853 } 2854 else if ( this.isLoggable( Level.WARNING ) ) 2855 { 2856 this.log( classLoader, Level.WARNING, getMissingSpecificationMessage( 2857 Locale.getDefault(), Invoker.class.getName() ), null ); 2858 2859 } 2860 2861 if ( invoker == null ) 2862 { 2863 invoker = this.getDefaultInvoker( model ); 2864 this.invokers.put( invokersLoader, invoker ); 2865 if ( this.isLoggable( Level.CONFIG ) ) 2866 { 2867 this.log( classLoader, Level.CONFIG, getDefaultInvokerInfoMessage( 2868 Locale.getDefault(), this.getClassLoaderInfo( classLoader, invokersLoader ) ), null ); 2869 2870 } 2871 } 2872 } 2873 2874 return invoker; 2875 } 2876 } 2877 catch ( final ModelObjectException e ) 2878 { 2879 throw new ObjectManagementException( getMessage( e ), e ); 2880 } 2881 catch ( final InstantiationException e ) 2882 { 2883 throw new ObjectManagementException( getMessage( e ), e ); 2884 } 2885 } 2886 2887 /** 2888 * Gets a new default invoker implementation instance. 2889 * 2890 * @return A new default invoker implementation instance. 2891 * 2892 * @see #getInvoker(java.lang.ClassLoader) 2893 * 2894 * @since 1.1 2895 * 2896 * @deprecated As of JOMC 1.2, replaced by method {@link #getDefaultInvoker(org.jomc.model.Modules)}. This method 2897 * will be removed in version 2.0. 2898 */ 2899 @Deprecated 2900 public Invoker getDefaultInvoker() 2901 { 2902 return new DefaultInvoker(); 2903 } 2904 2905 /** 2906 * Gets a new default invoker implementation instance. 2907 * 2908 * @param model The model to get a new default invoker implementation instance of. 2909 * 2910 * @return A new default invoker implementation instance. 2911 * 2912 * @throws NullPointerException if {@code model} is {@code null}. 2913 * @throws ObjectManagementException if getting a new default invoker implementation instance fails. 2914 * 2915 * @see #getInvoker(java.lang.ClassLoader) 2916 * 2917 * @since 1.2 2918 */ 2919 public Invoker getDefaultInvoker( final Modules model ) 2920 { 2921 if ( model == null ) 2922 { 2923 throw new NullPointerException( "model" ); 2924 } 2925 2926 try 2927 { 2928 final Invoker defaultInvoker = new DefaultInvoker(); 2929 model.getInstance( defaultInvoker ); 2930 return defaultInvoker; 2931 } 2932 catch ( final ModelObjectException e ) 2933 { 2934 throw new ObjectManagementException( getMessage( e ), e ); 2935 } 2936 } 2937 2938 /** 2939 * Gets an invocation for a given object, instance, method and arguments. 2940 * 2941 * @param object The object to invoke. 2942 * @param instance The instance of the object to invoke. 2943 * @param method The method to invoke on {@code object}. 2944 * @param arguments The arguments of the invocation or {@code null}. 2945 * 2946 * @return An invocation with {@code object}, {@code instance}, {@code method} and {@code arguments}. 2947 * 2948 * @throws NullPointerException if {@code object}, {@code instance} or {@code method} is {@code null}. 2949 * @throws InstantiationException if instantiating a new invocation fails. 2950 * 2951 * @deprecated As of JOMC 1.1, please use method {@link #getInvocation(java.lang.ClassLoader, java.lang.Object, org.jomc.model.Instance, java.lang.reflect.Method, java.lang.Object[])}. 2952 * This method will be removed in version 2.0. 2953 */ 2954 @Deprecated 2955 public Invocation getInvocation( final Object object, final Instance instance, final Method method, 2956 final Object[] arguments ) throws InstantiationException 2957 { 2958 return this.getInvocation( this.getDefaultClassLoader( object.getClass() ), object, instance, method, 2959 arguments ); 2960 2961 } 2962 2963 /** 2964 * Gets an invocation for a given class loader, object, instance, method and arguments. 2965 * 2966 * @param classLoader The class loader of the invocation. 2967 * @param object The object to invoke. 2968 * @param instance The instance of the object to invoke. 2969 * @param method The method to invoke on {@code object}. 2970 * @param arguments The arguments of the invocation or {@code null}. 2971 * 2972 * @return An invocation with {@code classLoader}, {@code object}, {@code instance}, {@code method} and 2973 * {@code arguments}. 2974 * 2975 * @throws NullPointerException if {@code classLoader} {@code object}, {@code instance} or {@code method} is 2976 * {@code null}. 2977 * @throws ObjectManagementException if getting an invocation fails. 2978 * 2979 * @see #getDefaultInvocation(org.jomc.model.Modules) 2980 * 2981 * @since 1.1 2982 */ 2983 public Invocation getInvocation( final ClassLoader classLoader, final Object object, final Instance instance, 2984 final Method method, final Object[] arguments ) 2985 { 2986 if ( classLoader == null ) 2987 { 2988 throw new NullPointerException( "classLoader" ); 2989 } 2990 if ( object == null ) 2991 { 2992 throw new NullPointerException( "object" ); 2993 } 2994 if ( instance == null ) 2995 { 2996 throw new NullPointerException( "instance" ); 2997 } 2998 if ( method == null ) 2999 { 3000 throw new NullPointerException( "method" ); 3001 } 3002 3003 try 3004 { 3005 Invocation invocation = null; 3006 final Modules model = this.getModules( classLoader ); 3007 final Specification invocationSpecification = model.getSpecification( Invocation.class ); 3008 3009 if ( invocationSpecification != null ) 3010 { 3011 final Implementations implementations = 3012 model.getImplementations( invocationSpecification.getIdentifier() ); 3013 3014 if ( implementations != null && !implementations.getImplementation().isEmpty() ) 3015 { 3016 for ( int i = 0, s0 = implementations.getImplementation().size(); i < s0; i++ ) 3017 { 3018 final Implementation impl = implementations.getImplementation().get( i ); 3019 3020 if ( invocation == null ) 3021 { 3022 final Instance invocationInstance = model.getInstance( impl.getIdentifier() ); 3023 3024 if ( invocationInstance != null ) 3025 { 3026 invocation = (Invocation) model.createObject( invocationInstance, classLoader ); 3027 } 3028 else if ( this.isLoggable( Level.WARNING ) ) 3029 { 3030 this.log( classLoader, Level.WARNING, getMissingInstanceMessage( 3031 Locale.getDefault(), impl.getIdentifier(), impl.getName() ), null ); 3032 3033 } 3034 } 3035 else if ( this.isLoggable( Level.CONFIG ) ) 3036 { 3037 this.log( classLoader, Level.CONFIG, getIgnoredInvocationMessage( 3038 Locale.getDefault(), impl.getIdentifier() ), null ); 3039 3040 } 3041 } 3042 } 3043 } 3044 else if ( this.isLoggable( Level.WARNING ) ) 3045 { 3046 this.log( classLoader, Level.WARNING, getMissingSpecificationMessage( 3047 Locale.getDefault(), Invocation.class.getName() ), null ); 3048 3049 } 3050 3051 if ( invocation == null ) 3052 { 3053 invocation = this.getDefaultInvocation( model ); 3054 } 3055 3056 invocation.getContext().put( DefaultInvocation.OBJECT_KEY, object ); 3057 invocation.getContext().put( DefaultInvocation.METHOD_KEY, method ); 3058 invocation.getContext().put( DefaultInvocation.ARGUMENTS_KEY, arguments ); 3059 invocation.getContext().put( DefaultInvocation.INSTANCE_KEY, instance ); 3060 invocation.getContext().put( DefaultInvocation.MODULES_KEY, model ); 3061 invocation.getContext().put( DefaultInvocation.CLASSLOADER_KEY, classLoader ); 3062 return invocation; 3063 } 3064 catch ( final ModelObjectException e ) 3065 { 3066 throw new ObjectManagementException( getMessage( e ), e ); 3067 } 3068 catch ( final InstantiationException e ) 3069 { 3070 throw new ObjectManagementException( getMessage( e ), e ); 3071 } 3072 } 3073 3074 /** 3075 * Gets a new default invocation implementation instance. 3076 * 3077 * @return A new default invocation implementation instance. 3078 * 3079 * @see #getInvocation(java.lang.Object, org.jomc.model.Instance, java.lang.reflect.Method, java.lang.Object[]) 3080 * 3081 * @since 1.1 3082 * 3083 * @deprecated As of JOMC 1.2, replaced by method {@link #getDefaultInvocation(org.jomc.model.Modules)}. This method 3084 * will be removed in version 2.0. 3085 */ 3086 @Deprecated 3087 public Invocation getDefaultInvocation() 3088 { 3089 return new DefaultInvocation(); 3090 } 3091 3092 /** 3093 * Gets a new default invocation implementation instance. 3094 * 3095 * @param model The model to get a new default invocation implementation instance of. 3096 * 3097 * @return A new default invocation implementation instance. 3098 * 3099 * @throws NullPointerException if {@code model} is {@code null}. 3100 * @throws ObjectManagementException if getting a new default invocation implementation instance fails. 3101 * 3102 * @see #getInvocation(java.lang.ClassLoader, java.lang.Object, org.jomc.model.Instance, java.lang.reflect.Method, java.lang.Object[]) 3103 * 3104 * @since 1.2 3105 */ 3106 public Invocation getDefaultInvocation( final Modules model ) 3107 { 3108 if ( model == null ) 3109 { 3110 throw new NullPointerException( "model" ); 3111 } 3112 3113 try 3114 { 3115 final Invocation defaultInvocation = new DefaultInvocation(); 3116 model.getInstance( defaultInvocation ); 3117 return defaultInvocation; 3118 } 3119 catch ( final ModelObjectException e ) 3120 { 3121 throw new ObjectManagementException( getMessage( e ), e ); 3122 } 3123 } 3124 3125 /** 3126 * Initializes the instance. 3127 * <p>This method is called once on first usage of a new instance.</p> 3128 * 3129 * @throws ObjectManagementException if initialization fails. 3130 */ 3131 public synchronized void initialize() 3132 { 3133 try 3134 { 3135 if ( !this.initialized ) 3136 { 3137 try 3138 { 3139 final long t0 = System.currentTimeMillis(); 3140 this.initialized = true; 3141 3142 this.listeners.clear(); 3143 this.modules.clear(); 3144 this.invokers.clear(); 3145 this.locators.clear(); 3146 this.scopes.clear(); 3147 3148 final ClassLoader classLoader = this.getDefaultClassLoader( this.getClass() ); 3149 final List<LogRecord> bootstrapLogRecords = new ArrayList<LogRecord>( 1024 ); 3150 final List<Listener> bootstrapListeners = new ArrayList<Listener>( 1 ); 3151 bootstrapListeners.add( new Listener() 3152 { 3153 3154 public void onLog( final Level level, final String message, final Throwable throwable ) 3155 { 3156 final LogRecord r = new LogRecord( level, message ); 3157 r.setThrown( throwable ); 3158 3159 bootstrapLogRecords.add( r ); 3160 } 3161 3162 } ); 3163 3164 this.listeners.put( this.getDefaultClassLoader( classLoader ), 3165 Collections.unmodifiableList( bootstrapListeners ) ); 3166 3167 final Modules model = this.getModules( classLoader ); 3168 final Specification objectManager = model.getSpecification( ObjectManager.class ); 3169 if ( objectManager == null ) 3170 { 3171 throw new InstantiationException( getMissingSpecificationMessage( 3172 Locale.getDefault(), ObjectManager.class.getName() ) ); 3173 3174 } 3175 3176 final Implementation thisImplementation = model.getImplementation( this.getClass() ); 3177 if ( thisImplementation == null ) 3178 { 3179 throw new InstantiationException( getMissingImplementationMessage( 3180 Locale.getDefault(), objectManager.getIdentifier(), this.getClass().getName() ) ); 3181 3182 } 3183 3184 final Instance thisInstance = model.getInstance( this ); 3185 if ( thisInstance == null ) 3186 { 3187 throw new InstantiationException( getMissingInstanceMessage( 3188 Locale.getDefault(), objectManager.getIdentifier(), thisImplementation.getName() ) ); 3189 3190 } 3191 3192 if ( objectManager.getScope() != null ) 3193 { 3194 final Scope scope = this.getScope( objectManager.getScope(), classLoader ); 3195 if ( scope == null ) 3196 { 3197 throw new InstantiationException( getMissingScopeMessage( 3198 Locale.getDefault(), objectManager.getScope() ) ); 3199 3200 } 3201 3202 scope.putObject( thisInstance.getIdentifier(), this ); 3203 } 3204 3205 if ( this.isLoggable( Level.FINE ) ) 3206 { 3207 this.log( Level.FINE, getImplementationInfoMessage( 3208 Locale.getDefault(), Long.valueOf( System.currentTimeMillis() - t0 ) ), null ); 3209 3210 } 3211 3212 this.listeners.clear(); 3213 3214 for ( LogRecord r : bootstrapLogRecords ) 3215 { 3216 this.log( classLoader, r.getLevel(), r.getMessage(), r.getThrown() ); 3217 } 3218 } 3219 catch ( final InstantiationException e ) 3220 { 3221 this.listeners.clear(); 3222 this.modules.clear(); 3223 this.invokers.clear(); 3224 this.locators.clear(); 3225 this.scopes.clear(); 3226 this.initialized = false; 3227 3228 throw new ObjectManagementException( getMessage( e ), e ); 3229 } 3230 } 3231 } 3232 catch ( final ModelObjectException e ) 3233 { 3234 throw new ObjectManagementException( getMessage( e ), e ); 3235 } 3236 } 3237 3238 /** 3239 * Creates a proxy object for a given object. 3240 * 3241 * @param instance The instance of {@code object}. 3242 * @param object The object to create a proxy object for. 3243 * @param classLoader The class loader to create the proxy object with. 3244 * 3245 * @return A new proxy object for {@code object}. 3246 * 3247 * @throws ObjectManagementException if creating a proxy object fails. 3248 */ 3249 private Object createProxy( final Instance instance, final Object object, final ClassLoader classLoader ) 3250 { 3251 try 3252 { 3253 Constructor<?> proxyClassConstructor = null; 3254 3255 synchronized ( proxyClassConstructors ) 3256 { 3257 Map<String, Reference<Constructor<?>>> map = proxyClassConstructors.get( classLoader ); 3258 3259 if ( map == null ) 3260 { 3261 map = new HashMap<String, Reference<Constructor<?>>>(); 3262 proxyClassConstructors.put( classLoader, map ); 3263 } 3264 3265 Reference<Constructor<?>> reference = map.get( instance.getIdentifier() ); 3266 3267 if ( reference != null ) 3268 { 3269 proxyClassConstructor = reference.get(); 3270 } 3271 3272 if ( proxyClassConstructor == null 3273 && ( reference != null || !map.containsKey( instance.getIdentifier() ) ) ) 3274 { 3275 final Class<?> proxyClass = instance.getJavaProxyClass( classLoader ); 3276 3277 if ( proxyClass != null ) 3278 { 3279 proxyClassConstructor = proxyClass.getConstructor( INVOCATION_HANDLER_ARGUMENTS ); 3280 } 3281 3282 map.put( instance.getIdentifier(), new WeakReference<Constructor<?>>( proxyClassConstructor ) ); 3283 } 3284 } 3285 3286 Object proxyObject = object; 3287 3288 if ( proxyClassConstructor != null ) 3289 { 3290 proxyObject = proxyClassConstructor.newInstance( new Object[] 3291 { 3292 new InvocationHandler() 3293 { 3294 3295 private final Invoker invoker = getInvoker( classLoader ); 3296 3297 public Object invoke( final Object proxy, final Method method, final Object[] args ) 3298 throws Throwable 3299 { 3300 if ( args != null ) 3301 { 3302 Object[] clonedArgs = args; 3303 3304 for ( int i = 0, s0 = clonedArgs.length; i < s0; i++ ) 3305 { 3306 if ( clonedArgs[i] == proxy ) 3307 { 3308 if ( clonedArgs == args ) 3309 { 3310 clonedArgs = clonedArgs.clone(); 3311 } 3312 3313 clonedArgs[i] = object; 3314 } 3315 } 3316 3317 return this.invoker.invoke( getInvocation( 3318 classLoader, object, instance, method, clonedArgs ) ); 3319 3320 } 3321 3322 return this.invoker.invoke( getInvocation( 3323 classLoader, object, instance, method, null ) ); 3324 3325 } 3326 3327 } 3328 } ); 3329 3330 } 3331 3332 return proxyObject; 3333 } 3334 catch ( final ModelObjectException e ) 3335 { 3336 throw new ObjectManagementException( getMessage( e ), e ); 3337 } 3338 catch ( final ClassNotFoundException e ) 3339 { 3340 throw new ObjectManagementException( getMessage( e ), e ); 3341 } 3342 catch ( final NoSuchMethodException e ) 3343 { 3344 throw new ObjectManagementException( getMessage( e ), e ); 3345 } 3346 catch ( final IllegalAccessException e ) 3347 { 3348 throw new ObjectManagementException( getMessage( e ), e ); 3349 } 3350 catch ( final InstantiationException e ) 3351 { 3352 throw new ObjectManagementException( getMessage( e ), e ); 3353 } 3354 catch ( final InvocationTargetException e ) 3355 { 3356 throw new ObjectManagementException( getMessage( e ), e ); 3357 } 3358 } 3359 3360 private void logModulesReport( final Modules mods, final ClassLoader classLoader ) 3361 { 3362 final StringBuilder modulesInfo = new StringBuilder( 8192 ); 3363 3364 this.log( classLoader, Level.FINEST, getModulesReportMessage( Locale.getDefault() ), null ); 3365 3366 modulesInfo.append( "\tClassLoader:" ).append( classLoader ); 3367 3368 if ( mods.getDocumentation() != null ) 3369 { 3370 modulesInfo.append( "|Documentation:" ).append( mods.getDocumentation().getText( 3371 Locale.getDefault().getLanguage() ).getValue() ); 3372 3373 } 3374 3375 this.log( classLoader, Level.FINEST, modulesInfo.toString(), null ); 3376 3377 for ( Module m : mods.getModule() ) 3378 { 3379 modulesInfo.setLength( 0 ); 3380 modulesInfo.append( "\tM:" ).append( m.getName() ); 3381 3382 if ( m.getVersion() != null ) 3383 { 3384 modulesInfo.append( "|Version:" ).append( m.getVersion() ); 3385 } 3386 if ( m.getVendor() != null ) 3387 { 3388 modulesInfo.append( "|Vendor:" ).append( m.getVendor() ); 3389 } 3390 3391 this.log( classLoader, Level.FINEST, modulesInfo.toString(), null ); 3392 modulesInfo.setLength( 0 ); 3393 3394 if ( m.getSpecifications() != null ) 3395 { 3396 for ( Specification s : m.getSpecifications().getSpecification() ) 3397 { 3398 modulesInfo.append( "\t\t" ); 3399 this.appendSpecificationInfo( s, modulesInfo ); 3400 this.log( classLoader, Level.FINEST, modulesInfo.toString(), null ); 3401 modulesInfo.setLength( 0 ); 3402 3403 final Implementations available = mods.getImplementations( s.getIdentifier() ); 3404 3405 if ( available != null ) 3406 { 3407 for ( Implementation i : available.getImplementation() ) 3408 { 3409 modulesInfo.append( "\t\t\t" ); 3410 this.appendImplementationInfo( i, modulesInfo ).append( "|Module:" ). 3411 append( mods.getModuleOfImplementation( i.getIdentifier() ).getName() ); 3412 3413 this.log( classLoader, Level.FINEST, modulesInfo.toString(), null ); 3414 modulesInfo.setLength( 0 ); 3415 } 3416 } 3417 } 3418 } 3419 3420 if ( m.getImplementations() != null ) 3421 { 3422 for ( Implementation i : m.getImplementations().getImplementation() ) 3423 { 3424 modulesInfo.append( "\t\t" ); 3425 this.appendImplementationInfo( i, modulesInfo ); 3426 this.log( classLoader, Level.FINEST, modulesInfo.toString(), null ); 3427 modulesInfo.setLength( 0 ); 3428 3429 if ( i.getImplementations() != null ) 3430 { 3431 modulesInfo.append( "\t\t\t" ); 3432 for ( ImplementationReference r : i.getImplementations().getReference() ) 3433 { 3434 this.appendImplementationInfo( 3435 mods.getImplementation( r.getIdentifier() ), modulesInfo ).append( "|Module:" ). 3436 append( mods.getModuleOfImplementation( r.getIdentifier() ).getName() ); 3437 3438 this.log( classLoader, Level.FINEST, modulesInfo.toString(), null ); 3439 modulesInfo.setLength( 0 ); 3440 } 3441 } 3442 if ( i.getSpecifications() != null ) 3443 { 3444 for ( SpecificationReference s : i.getSpecifications().getReference() ) 3445 { 3446 modulesInfo.append( "\t\t\tS:" ).append( s.getIdentifier() ); 3447 3448 if ( s.getVersion() != null ) 3449 { 3450 modulesInfo.append( "|Version:" ).append( s.getVersion() ); 3451 } 3452 3453 modulesInfo.append( "|Module:" ).append( mods.getModuleOfSpecification( 3454 s.getIdentifier() ).getName() ); 3455 3456 this.log( classLoader, Level.FINEST, modulesInfo.toString(), null ); 3457 modulesInfo.setLength( 0 ); 3458 } 3459 } 3460 3461 if ( i.getDependencies() != null ) 3462 { 3463 for ( Dependency d : i.getDependencies().getDependency() ) 3464 { 3465 modulesInfo.append( "\t\t\tD:" ).append( d.getName() ).append( "|Identifier:" ). 3466 append( d.getIdentifier() ); 3467 3468 if ( d.getImplementationName() != null ) 3469 { 3470 modulesInfo.append( "|Name:" ).append( d.getImplementationName() ); 3471 } 3472 3473 modulesInfo.append( "|Module:" ).append( mods.getModuleOfSpecification( 3474 d.getIdentifier() ).getName() ); 3475 3476 this.log( classLoader, Level.FINEST, modulesInfo.toString(), null ); 3477 modulesInfo.setLength( 0 ); 3478 3479 final Implementations available = mods.getImplementations( d.getIdentifier() ); 3480 3481 if ( available != null ) 3482 { 3483 for ( Implementation di : available.getImplementation() ) 3484 { 3485 modulesInfo.append( "\t\t\t\t" ); 3486 this.appendImplementationInfo( di, modulesInfo ).append( "|Module:" ). 3487 append( mods.getModuleOfImplementation( di.getIdentifier() ).getName() ); 3488 3489 this.log( classLoader, Level.FINEST, modulesInfo.toString(), null ); 3490 modulesInfo.setLength( 0 ); 3491 } 3492 } 3493 } 3494 } 3495 3496 if ( i.getMessages() != null ) 3497 { 3498 for ( Message msg : i.getMessages().getMessage() ) 3499 { 3500 modulesInfo.append( "\t\t\tM:" ).append( msg.getName() ).append( "|Text:" ). 3501 append( msg.getTemplate().getText( Locale.getDefault().getLanguage() ).getValue() ); 3502 3503 this.log( classLoader, Level.FINEST, modulesInfo.toString(), null ); 3504 modulesInfo.setLength( 0 ); 3505 } 3506 } 3507 3508 if ( i.getProperties() != null ) 3509 { 3510 for ( Property p : i.getProperties().getProperty() ) 3511 { 3512 modulesInfo.append( "\t\t\tP:" ).append( p.getName() ); 3513 modulesInfo.append( "|Type:" ).append( p.getType() ); 3514 modulesInfo.append( "|Value:" ).append( p.getValue() ); 3515 3516 try 3517 { 3518 modulesInfo.append( "|JavaValue:" ).append( p.getJavaValue( classLoader ) ); 3519 } 3520 catch ( final ModelObjectException e ) 3521 { 3522 modulesInfo.append( "|JavaValue:" ).append( e ); 3523 } 3524 3525 this.log( classLoader, Level.FINEST, modulesInfo.toString(), null ); 3526 modulesInfo.setLength( 0 ); 3527 } 3528 } 3529 } 3530 } 3531 } 3532 } 3533 3534 private StringBuilder appendSpecificationInfo( final Specification s, final StringBuilder b ) 3535 { 3536 b.append( "S:" ).append( s.getIdentifier() ); 3537 if ( s.getVersion() != null ) 3538 { 3539 b.append( "|Version:" ).append( s.getVersion() ); 3540 } 3541 if ( s.getVendor() != null ) 3542 { 3543 b.append( "|Vendor:" ).append( s.getVendor() ); 3544 } 3545 3546 b.append( "|Multiplicity:" ).append( s.getMultiplicity() ).append( "|Scope:" ). 3547 append( s.getScope() == null ? "Multiton" : s.getScope() ); 3548 3549 if ( s.getClazz() != null ) 3550 { 3551 b.append( "|Class:" ).append( s.getClazz() ); 3552 } 3553 3554 return b; 3555 } 3556 3557 private StringBuilder appendImplementationInfo( final Implementation i, final StringBuilder b ) 3558 { 3559 b.append( "I:" ).append( i.getIdentifier() ).append( "|Name:" ).append( i.getName() ).append( "|Abstract:" ). 3560 append( i.isAbstract() ).append( "|Final:" ).append( i.isFinal() ).append( "|Stateless:" ). 3561 append( i.isStateless() ); 3562 3563 if ( i.getVersion() != null ) 3564 { 3565 b.append( "|Version:" ).append( i.getVersion() ); 3566 } 3567 if ( i.getVendor() != null ) 3568 { 3569 b.append( "|Vendor:" ).append( i.getVendor() ); 3570 } 3571 if ( i.getClazz() != null ) 3572 { 3573 b.append( "|Class:" ).append( i.getClazz() ); 3574 } 3575 if ( i.getLocation() != null ) 3576 { 3577 b.append( "|Location:" ).append( i.getLocation() ); 3578 } 3579 3580 return b; 3581 } 3582 3583 private String getClassLoaderInfo( final ClassLoader current, final ClassLoader parent ) 3584 { 3585 final StringBuilder b = new StringBuilder(); 3586 appendClassLoaderInfo( b, current ); 3587 3588 if ( parent != null ) 3589 { 3590 b.append( " => " ); 3591 appendClassLoaderInfo( b, parent ); 3592 } 3593 3594 return b.toString(); 3595 } 3596 3597 private String getObjectInfo( final Object object ) 3598 { 3599 final StringBuilder b = new StringBuilder(); 3600 appendObjectInfo( b, object ); 3601 b.append( " @ " ); 3602 appendClassLoaderInfo( b, this.getDefaultClassLoader( object.getClass() ) ); 3603 return b.toString(); 3604 } 3605 3606 private static StringBuilder appendClassLoaderInfo( final StringBuilder b, final ClassLoader classLoader ) 3607 { 3608 return b.append( "(" ).append( Integer.toHexString( System.identityHashCode( classLoader ) ) ).append( ")" ). 3609 append( classLoader ); 3610 3611 } 3612 3613 private static StringBuilder appendObjectInfo( final StringBuilder b, final Object object ) 3614 { 3615 return b.append( "(" ).append( Integer.toHexString( System.identityHashCode( object ) ) ).append( ")" ). 3616 append( object ); 3617 3618 } 3619 3620 private static String getMessage( final Throwable t ) 3621 { 3622 return t != null ? t.getMessage() != null ? t.getMessage() : getMessage( t.getCause() ) : null; 3623 } 3624 3625 private static Specification createDefaultSpecification( final Class<?> specification, 3626 final Multiplicity multiplicity, final String scope ) 3627 { 3628 final Specification s = new Specification(); 3629 s.setClassDeclaration( true ); 3630 s.setClazz( specification.getName() ); 3631 s.setIdentifier( specification.getName() ); 3632 s.setMultiplicity( multiplicity ); 3633 s.setScope( scope ); 3634 s.setVendor( getDefaultModulesVendor( Locale.getDefault() ) ); 3635 s.setVersion( getDefaultModulesVersion( Locale.getDefault() ) ); 3636 return s; 3637 } 3638 3639 private static Implementation createDefaultImplementation( final Class<?> implementation, final String name ) 3640 { 3641 final Implementation i = new Implementation(); 3642 i.setClassDeclaration( true ); 3643 i.setClazz( implementation.getName() ); 3644 i.setIdentifier( implementation.getName() ); 3645 i.setName( name ); 3646 i.setVendor( getDefaultModulesVendor( Locale.getDefault() ) ); 3647 i.setVersion( getDefaultModulesVersion( Locale.getDefault() ) ); 3648 return i; 3649 } 3650 3651 // SECTION-END 3652 // SECTION-START[Dependencies] 3653 // SECTION-END 3654 // SECTION-START[Properties] 3655 // SECTION-END 3656 // SECTION-START[Messages] 3657 // <editor-fold defaultstate="collapsed" desc=" Generated Messages "> 3658 /** 3659 * Gets the text of the {@code <Creating Modules Info>} message. 3660 * <p><dl> 3661 * <dt><b>Languages:</b></dt> 3662 * <dd>English (default)</dd> 3663 * <dd>Deutsch</dd> 3664 * <dt><b>Final:</b></dt><dd>No</dd> 3665 * </dl></p> 3666 * @param locale The locale of the message to return. 3667 * @param classLoaderInfo Format argument. 3668 * @return The text of the {@code <Creating Modules Info>} message for {@code locale}. 3669 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 3670 */ 3671 @SuppressWarnings("unused") 3672 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 3673 private static String getCreatingModulesInfo( final java.util.Locale locale, final java.lang.String classLoaderInfo ) 3674 { 3675 java.io.BufferedReader reader = null; 3676 boolean suppressExceptionOnClose = true; 3677 3678 try 3679 { 3680 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Creating Modules Info" ), classLoaderInfo, (Object) null ); 3681 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 3682 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 3683 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 3684 3685 String line; 3686 while ( ( line = reader.readLine() ) != null ) 3687 { 3688 builder.append( lineSeparator ).append( line ); 3689 } 3690 3691 suppressExceptionOnClose = false; 3692 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 3693 } 3694 catch( final java.lang.ClassCastException e ) 3695 { 3696 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3697 } 3698 catch( final java.lang.IllegalArgumentException e ) 3699 { 3700 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3701 } 3702 catch( final java.util.MissingResourceException e ) 3703 { 3704 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3705 } 3706 catch( final java.io.IOException e ) 3707 { 3708 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3709 } 3710 finally 3711 { 3712 try 3713 { 3714 if( reader != null ) 3715 { 3716 reader.close(); 3717 } 3718 } 3719 catch( final java.io.IOException e ) 3720 { 3721 if( !suppressExceptionOnClose ) 3722 { 3723 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3724 } 3725 } 3726 } 3727 } 3728 /** 3729 * Gets the text of the {@code <Default Implementation Name>} message. 3730 * <p><dl> 3731 * <dt><b>Languages:</b></dt> 3732 * <dd>English (default)</dd> 3733 * <dd>Deutsch</dd> 3734 * <dt><b>Final:</b></dt><dd>No</dd> 3735 * </dl></p> 3736 * @param locale The locale of the message to return. 3737 * @return The text of the {@code <Default Implementation Name>} message for {@code locale}. 3738 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 3739 */ 3740 @SuppressWarnings("unused") 3741 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 3742 private static String getDefaultImplementationName( final java.util.Locale locale ) 3743 { 3744 java.io.BufferedReader reader = null; 3745 boolean suppressExceptionOnClose = true; 3746 3747 try 3748 { 3749 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Default Implementation Name" ), (Object) null ); 3750 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 3751 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 3752 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 3753 3754 String line; 3755 while ( ( line = reader.readLine() ) != null ) 3756 { 3757 builder.append( lineSeparator ).append( line ); 3758 } 3759 3760 suppressExceptionOnClose = false; 3761 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 3762 } 3763 catch( final java.lang.ClassCastException e ) 3764 { 3765 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3766 } 3767 catch( final java.lang.IllegalArgumentException e ) 3768 { 3769 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3770 } 3771 catch( final java.util.MissingResourceException e ) 3772 { 3773 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3774 } 3775 catch( final java.io.IOException e ) 3776 { 3777 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3778 } 3779 finally 3780 { 3781 try 3782 { 3783 if( reader != null ) 3784 { 3785 reader.close(); 3786 } 3787 } 3788 catch( final java.io.IOException e ) 3789 { 3790 if( !suppressExceptionOnClose ) 3791 { 3792 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3793 } 3794 } 3795 } 3796 } 3797 /** 3798 * Gets the text of the {@code <Default Invoker Info Message>} message. 3799 * <p><dl> 3800 * <dt><b>Languages:</b></dt> 3801 * <dd>English (default)</dd> 3802 * <dd>Deutsch</dd> 3803 * <dt><b>Final:</b></dt><dd>No</dd> 3804 * </dl></p> 3805 * @param locale The locale of the message to return. 3806 * @param classLoaderInfo Format argument. 3807 * @return The text of the {@code <Default Invoker Info Message>} message for {@code locale}. 3808 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 3809 */ 3810 @SuppressWarnings("unused") 3811 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 3812 private static String getDefaultInvokerInfoMessage( final java.util.Locale locale, final java.lang.String classLoaderInfo ) 3813 { 3814 java.io.BufferedReader reader = null; 3815 boolean suppressExceptionOnClose = true; 3816 3817 try 3818 { 3819 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Default Invoker Info Message" ), classLoaderInfo, (Object) null ); 3820 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 3821 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 3822 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 3823 3824 String line; 3825 while ( ( line = reader.readLine() ) != null ) 3826 { 3827 builder.append( lineSeparator ).append( line ); 3828 } 3829 3830 suppressExceptionOnClose = false; 3831 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 3832 } 3833 catch( final java.lang.ClassCastException e ) 3834 { 3835 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3836 } 3837 catch( final java.lang.IllegalArgumentException e ) 3838 { 3839 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3840 } 3841 catch( final java.util.MissingResourceException e ) 3842 { 3843 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3844 } 3845 catch( final java.io.IOException e ) 3846 { 3847 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3848 } 3849 finally 3850 { 3851 try 3852 { 3853 if( reader != null ) 3854 { 3855 reader.close(); 3856 } 3857 } 3858 catch( final java.io.IOException e ) 3859 { 3860 if( !suppressExceptionOnClose ) 3861 { 3862 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3863 } 3864 } 3865 } 3866 } 3867 /** 3868 * Gets the text of the {@code <Default Listener Info>} message. 3869 * <p><dl> 3870 * <dt><b>Languages:</b></dt> 3871 * <dd>English (default)</dd> 3872 * <dd>Deutsch</dd> 3873 * <dt><b>Final:</b></dt><dd>No</dd> 3874 * </dl></p> 3875 * @param locale The locale of the message to return. 3876 * @param classLoaderInfo Format argument. 3877 * @return The text of the {@code <Default Listener Info>} message for {@code locale}. 3878 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 3879 */ 3880 @SuppressWarnings("unused") 3881 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 3882 private static String getDefaultListenerInfo( final java.util.Locale locale, final java.lang.String classLoaderInfo ) 3883 { 3884 java.io.BufferedReader reader = null; 3885 boolean suppressExceptionOnClose = true; 3886 3887 try 3888 { 3889 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Default Listener Info" ), classLoaderInfo, (Object) null ); 3890 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 3891 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 3892 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 3893 3894 String line; 3895 while ( ( line = reader.readLine() ) != null ) 3896 { 3897 builder.append( lineSeparator ).append( line ); 3898 } 3899 3900 suppressExceptionOnClose = false; 3901 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 3902 } 3903 catch( final java.lang.ClassCastException e ) 3904 { 3905 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3906 } 3907 catch( final java.lang.IllegalArgumentException e ) 3908 { 3909 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3910 } 3911 catch( final java.util.MissingResourceException e ) 3912 { 3913 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3914 } 3915 catch( final java.io.IOException e ) 3916 { 3917 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3918 } 3919 finally 3920 { 3921 try 3922 { 3923 if( reader != null ) 3924 { 3925 reader.close(); 3926 } 3927 } 3928 catch( final java.io.IOException e ) 3929 { 3930 if( !suppressExceptionOnClose ) 3931 { 3932 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3933 } 3934 } 3935 } 3936 } 3937 /** 3938 * Gets the text of the {@code <Default Locator Info Message>} message. 3939 * <p><dl> 3940 * <dt><b>Languages:</b></dt> 3941 * <dd>English (default)</dd> 3942 * <dd>Deutsch</dd> 3943 * <dt><b>Final:</b></dt><dd>No</dd> 3944 * </dl></p> 3945 * @param locale The locale of the message to return. 3946 * @param schemeInfo Format argument. 3947 * @param classLoaderInfo Format argument. 3948 * @return The text of the {@code <Default Locator Info Message>} message for {@code locale}. 3949 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 3950 */ 3951 @SuppressWarnings("unused") 3952 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 3953 private static String getDefaultLocatorInfoMessage( final java.util.Locale locale, final java.lang.String schemeInfo, final java.lang.String classLoaderInfo ) 3954 { 3955 java.io.BufferedReader reader = null; 3956 boolean suppressExceptionOnClose = true; 3957 3958 try 3959 { 3960 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Default Locator Info Message" ), schemeInfo, classLoaderInfo, (Object) null ); 3961 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 3962 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 3963 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 3964 3965 String line; 3966 while ( ( line = reader.readLine() ) != null ) 3967 { 3968 builder.append( lineSeparator ).append( line ); 3969 } 3970 3971 suppressExceptionOnClose = false; 3972 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 3973 } 3974 catch( final java.lang.ClassCastException e ) 3975 { 3976 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3977 } 3978 catch( final java.lang.IllegalArgumentException e ) 3979 { 3980 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3981 } 3982 catch( final java.util.MissingResourceException e ) 3983 { 3984 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3985 } 3986 catch( final java.io.IOException e ) 3987 { 3988 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 3989 } 3990 finally 3991 { 3992 try 3993 { 3994 if( reader != null ) 3995 { 3996 reader.close(); 3997 } 3998 } 3999 catch( final java.io.IOException e ) 4000 { 4001 if( !suppressExceptionOnClose ) 4002 { 4003 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4004 } 4005 } 4006 } 4007 } 4008 /** 4009 * Gets the text of the {@code <Default Log Level Info Message>} message. 4010 * <p><dl> 4011 * <dt><b>Languages:</b></dt> 4012 * <dd>English (default)</dd> 4013 * <dd>Deutsch</dd> 4014 * <dt><b>Final:</b></dt><dd>No</dd> 4015 * </dl></p> 4016 * @param locale The locale of the message to return. 4017 * @param logLevel Format argument. 4018 * @return The text of the {@code <Default Log Level Info Message>} message for {@code locale}. 4019 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 4020 */ 4021 @SuppressWarnings("unused") 4022 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 4023 private static String getDefaultLogLevelInfoMessage( final java.util.Locale locale, final java.lang.String logLevel ) 4024 { 4025 java.io.BufferedReader reader = null; 4026 boolean suppressExceptionOnClose = true; 4027 4028 try 4029 { 4030 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Default Log Level Info Message" ), logLevel, (Object) null ); 4031 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 4032 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 4033 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 4034 4035 String line; 4036 while ( ( line = reader.readLine() ) != null ) 4037 { 4038 builder.append( lineSeparator ).append( line ); 4039 } 4040 4041 suppressExceptionOnClose = false; 4042 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 4043 } 4044 catch( final java.lang.ClassCastException e ) 4045 { 4046 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4047 } 4048 catch( final java.lang.IllegalArgumentException e ) 4049 { 4050 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4051 } 4052 catch( final java.util.MissingResourceException e ) 4053 { 4054 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4055 } 4056 catch( final java.io.IOException e ) 4057 { 4058 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4059 } 4060 finally 4061 { 4062 try 4063 { 4064 if( reader != null ) 4065 { 4066 reader.close(); 4067 } 4068 } 4069 catch( final java.io.IOException e ) 4070 { 4071 if( !suppressExceptionOnClose ) 4072 { 4073 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4074 } 4075 } 4076 } 4077 } 4078 /** 4079 * Gets the text of the {@code <Default Model Identifier Info>} message. 4080 * <p><dl> 4081 * <dt><b>Languages:</b></dt> 4082 * <dd>English (default)</dd> 4083 * <dd>Deutsch</dd> 4084 * <dt><b>Final:</b></dt><dd>No</dd> 4085 * </dl></p> 4086 * @param locale The locale of the message to return. 4087 * @param defaultValue Format argument. 4088 * @return The text of the {@code <Default Model Identifier Info>} message for {@code locale}. 4089 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 4090 */ 4091 @SuppressWarnings("unused") 4092 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 4093 private static String getDefaultModelIdentifierInfo( final java.util.Locale locale, final java.lang.String defaultValue ) 4094 { 4095 java.io.BufferedReader reader = null; 4096 boolean suppressExceptionOnClose = true; 4097 4098 try 4099 { 4100 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Default Model Identifier Info" ), defaultValue, (Object) null ); 4101 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 4102 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 4103 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 4104 4105 String line; 4106 while ( ( line = reader.readLine() ) != null ) 4107 { 4108 builder.append( lineSeparator ).append( line ); 4109 } 4110 4111 suppressExceptionOnClose = false; 4112 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 4113 } 4114 catch( final java.lang.ClassCastException e ) 4115 { 4116 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4117 } 4118 catch( final java.lang.IllegalArgumentException e ) 4119 { 4120 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4121 } 4122 catch( final java.util.MissingResourceException e ) 4123 { 4124 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4125 } 4126 catch( final java.io.IOException e ) 4127 { 4128 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4129 } 4130 finally 4131 { 4132 try 4133 { 4134 if( reader != null ) 4135 { 4136 reader.close(); 4137 } 4138 } 4139 catch( final java.io.IOException e ) 4140 { 4141 if( !suppressExceptionOnClose ) 4142 { 4143 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4144 } 4145 } 4146 } 4147 } 4148 /** 4149 * Gets the text of the {@code <Default Model Object Classpah Resolution Enabled Info>} message. 4150 * <p><dl> 4151 * <dt><b>Languages:</b></dt> 4152 * <dd>English (default)</dd> 4153 * <dd>Deutsch</dd> 4154 * <dt><b>Final:</b></dt><dd>No</dd> 4155 * </dl></p> 4156 * @param locale The locale of the message to return. 4157 * @param defaultValue Format argument. 4158 * @return The text of the {@code <Default Model Object Classpah Resolution Enabled Info>} message for {@code locale}. 4159 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 4160 */ 4161 @SuppressWarnings("unused") 4162 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 4163 private static String getDefaultModelObjectClasspahResolutionEnabledInfo( final java.util.Locale locale, final java.lang.String defaultValue ) 4164 { 4165 java.io.BufferedReader reader = null; 4166 boolean suppressExceptionOnClose = true; 4167 4168 try 4169 { 4170 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Default Model Object Classpah Resolution Enabled Info" ), defaultValue, (Object) null ); 4171 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 4172 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 4173 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 4174 4175 String line; 4176 while ( ( line = reader.readLine() ) != null ) 4177 { 4178 builder.append( lineSeparator ).append( line ); 4179 } 4180 4181 suppressExceptionOnClose = false; 4182 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 4183 } 4184 catch( final java.lang.ClassCastException e ) 4185 { 4186 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4187 } 4188 catch( final java.lang.IllegalArgumentException e ) 4189 { 4190 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4191 } 4192 catch( final java.util.MissingResourceException e ) 4193 { 4194 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4195 } 4196 catch( final java.io.IOException e ) 4197 { 4198 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4199 } 4200 finally 4201 { 4202 try 4203 { 4204 if( reader != null ) 4205 { 4206 reader.close(); 4207 } 4208 } 4209 catch( final java.io.IOException e ) 4210 { 4211 if( !suppressExceptionOnClose ) 4212 { 4213 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4214 } 4215 } 4216 } 4217 } 4218 /** 4219 * Gets the text of the {@code <Default Model Processing Enabled Info>} message. 4220 * <p><dl> 4221 * <dt><b>Languages:</b></dt> 4222 * <dd>English (default)</dd> 4223 * <dd>Deutsch</dd> 4224 * <dt><b>Final:</b></dt><dd>No</dd> 4225 * </dl></p> 4226 * @param locale The locale of the message to return. 4227 * @param defaultValue Format argument. 4228 * @return The text of the {@code <Default Model Processing Enabled Info>} message for {@code locale}. 4229 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 4230 */ 4231 @SuppressWarnings("unused") 4232 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 4233 private static String getDefaultModelProcessingEnabledInfo( final java.util.Locale locale, final java.lang.String defaultValue ) 4234 { 4235 java.io.BufferedReader reader = null; 4236 boolean suppressExceptionOnClose = true; 4237 4238 try 4239 { 4240 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Default Model Processing Enabled Info" ), defaultValue, (Object) null ); 4241 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 4242 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 4243 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 4244 4245 String line; 4246 while ( ( line = reader.readLine() ) != null ) 4247 { 4248 builder.append( lineSeparator ).append( line ); 4249 } 4250 4251 suppressExceptionOnClose = false; 4252 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 4253 } 4254 catch( final java.lang.ClassCastException e ) 4255 { 4256 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4257 } 4258 catch( final java.lang.IllegalArgumentException e ) 4259 { 4260 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4261 } 4262 catch( final java.util.MissingResourceException e ) 4263 { 4264 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4265 } 4266 catch( final java.io.IOException e ) 4267 { 4268 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4269 } 4270 finally 4271 { 4272 try 4273 { 4274 if( reader != null ) 4275 { 4276 reader.close(); 4277 } 4278 } 4279 catch( final java.io.IOException e ) 4280 { 4281 if( !suppressExceptionOnClose ) 4282 { 4283 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4284 } 4285 } 4286 } 4287 } 4288 /** 4289 * Gets the text of the {@code <Default Module Name>} message. 4290 * <p><dl> 4291 * <dt><b>Languages:</b></dt> 4292 * <dd>English (default)</dd> 4293 * <dd>Deutsch</dd> 4294 * <dt><b>Final:</b></dt><dd>No</dd> 4295 * </dl></p> 4296 * @param locale The locale of the message to return. 4297 * @return The text of the {@code <Default Module Name>} message for {@code locale}. 4298 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 4299 */ 4300 @SuppressWarnings("unused") 4301 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 4302 private static String getDefaultModuleName( final java.util.Locale locale ) 4303 { 4304 java.io.BufferedReader reader = null; 4305 boolean suppressExceptionOnClose = true; 4306 4307 try 4308 { 4309 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Default Module Name" ), (Object) null ); 4310 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 4311 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 4312 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 4313 4314 String line; 4315 while ( ( line = reader.readLine() ) != null ) 4316 { 4317 builder.append( lineSeparator ).append( line ); 4318 } 4319 4320 suppressExceptionOnClose = false; 4321 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 4322 } 4323 catch( final java.lang.ClassCastException e ) 4324 { 4325 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4326 } 4327 catch( final java.lang.IllegalArgumentException e ) 4328 { 4329 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4330 } 4331 catch( final java.util.MissingResourceException e ) 4332 { 4333 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4334 } 4335 catch( final java.io.IOException e ) 4336 { 4337 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4338 } 4339 finally 4340 { 4341 try 4342 { 4343 if( reader != null ) 4344 { 4345 reader.close(); 4346 } 4347 } 4348 catch( final java.io.IOException e ) 4349 { 4350 if( !suppressExceptionOnClose ) 4351 { 4352 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4353 } 4354 } 4355 } 4356 } 4357 /** 4358 * Gets the text of the {@code <Default Modules Vendor>} message. 4359 * <p><dl> 4360 * <dt><b>Languages:</b></dt> 4361 * <dd>English (default)</dd> 4362 * <dd>Deutsch</dd> 4363 * <dt><b>Final:</b></dt><dd>No</dd> 4364 * </dl></p> 4365 * @param locale The locale of the message to return. 4366 * @return The text of the {@code <Default Modules Vendor>} message for {@code locale}. 4367 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 4368 */ 4369 @SuppressWarnings("unused") 4370 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 4371 private static String getDefaultModulesVendor( final java.util.Locale locale ) 4372 { 4373 java.io.BufferedReader reader = null; 4374 boolean suppressExceptionOnClose = true; 4375 4376 try 4377 { 4378 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Default Modules Vendor" ), (Object) null ); 4379 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 4380 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 4381 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 4382 4383 String line; 4384 while ( ( line = reader.readLine() ) != null ) 4385 { 4386 builder.append( lineSeparator ).append( line ); 4387 } 4388 4389 suppressExceptionOnClose = false; 4390 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 4391 } 4392 catch( final java.lang.ClassCastException e ) 4393 { 4394 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4395 } 4396 catch( final java.lang.IllegalArgumentException e ) 4397 { 4398 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4399 } 4400 catch( final java.util.MissingResourceException e ) 4401 { 4402 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4403 } 4404 catch( final java.io.IOException e ) 4405 { 4406 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4407 } 4408 finally 4409 { 4410 try 4411 { 4412 if( reader != null ) 4413 { 4414 reader.close(); 4415 } 4416 } 4417 catch( final java.io.IOException e ) 4418 { 4419 if( !suppressExceptionOnClose ) 4420 { 4421 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4422 } 4423 } 4424 } 4425 } 4426 /** 4427 * Gets the text of the {@code <Default Modules Version>} message. 4428 * <p><dl> 4429 * <dt><b>Languages:</b></dt> 4430 * <dd>English (default)</dd> 4431 * <dd>Deutsch</dd> 4432 * <dt><b>Final:</b></dt><dd>No</dd> 4433 * </dl></p> 4434 * @param locale The locale of the message to return. 4435 * @return The text of the {@code <Default Modules Version>} message for {@code locale}. 4436 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 4437 */ 4438 @SuppressWarnings("unused") 4439 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 4440 private static String getDefaultModulesVersion( final java.util.Locale locale ) 4441 { 4442 java.io.BufferedReader reader = null; 4443 boolean suppressExceptionOnClose = true; 4444 4445 try 4446 { 4447 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Default Modules Version" ), (Object) null ); 4448 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 4449 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 4450 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 4451 4452 String line; 4453 while ( ( line = reader.readLine() ) != null ) 4454 { 4455 builder.append( lineSeparator ).append( line ); 4456 } 4457 4458 suppressExceptionOnClose = false; 4459 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 4460 } 4461 catch( final java.lang.ClassCastException e ) 4462 { 4463 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4464 } 4465 catch( final java.lang.IllegalArgumentException e ) 4466 { 4467 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4468 } 4469 catch( final java.util.MissingResourceException e ) 4470 { 4471 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4472 } 4473 catch( final java.io.IOException e ) 4474 { 4475 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4476 } 4477 finally 4478 { 4479 try 4480 { 4481 if( reader != null ) 4482 { 4483 reader.close(); 4484 } 4485 } 4486 catch( final java.io.IOException e ) 4487 { 4488 if( !suppressExceptionOnClose ) 4489 { 4490 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4491 } 4492 } 4493 } 4494 } 4495 /** 4496 * Gets the text of the {@code <Default Modules Warning>} message. 4497 * <p><dl> 4498 * <dt><b>Languages:</b></dt> 4499 * <dd>English (default)</dd> 4500 * <dd>Deutsch</dd> 4501 * <dt><b>Final:</b></dt><dd>No</dd> 4502 * </dl></p> 4503 * @param locale The locale of the message to return. 4504 * @param modelInfo Format argument. 4505 * @param classLoaderInfo Format argument. 4506 * @return The text of the {@code <Default Modules Warning>} message for {@code locale}. 4507 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 4508 */ 4509 @SuppressWarnings("unused") 4510 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 4511 private static String getDefaultModulesWarning( final java.util.Locale locale, final java.lang.String modelInfo, final java.lang.String classLoaderInfo ) 4512 { 4513 java.io.BufferedReader reader = null; 4514 boolean suppressExceptionOnClose = true; 4515 4516 try 4517 { 4518 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Default Modules Warning" ), modelInfo, classLoaderInfo, (Object) null ); 4519 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 4520 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 4521 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 4522 4523 String line; 4524 while ( ( line = reader.readLine() ) != null ) 4525 { 4526 builder.append( lineSeparator ).append( line ); 4527 } 4528 4529 suppressExceptionOnClose = false; 4530 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 4531 } 4532 catch( final java.lang.ClassCastException e ) 4533 { 4534 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4535 } 4536 catch( final java.lang.IllegalArgumentException e ) 4537 { 4538 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4539 } 4540 catch( final java.util.MissingResourceException e ) 4541 { 4542 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4543 } 4544 catch( final java.io.IOException e ) 4545 { 4546 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4547 } 4548 finally 4549 { 4550 try 4551 { 4552 if( reader != null ) 4553 { 4554 reader.close(); 4555 } 4556 } 4557 catch( final java.io.IOException e ) 4558 { 4559 if( !suppressExceptionOnClose ) 4560 { 4561 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4562 } 4563 } 4564 } 4565 } 4566 /** 4567 * Gets the text of the {@code <Default Scope Info Message>} message. 4568 * <p><dl> 4569 * <dt><b>Languages:</b></dt> 4570 * <dd>English (default)</dd> 4571 * <dd>Deutsch</dd> 4572 * <dt><b>Final:</b></dt><dd>No</dd> 4573 * </dl></p> 4574 * @param locale The locale of the message to return. 4575 * @param scopeIdentifier Format argument. 4576 * @param classLoaderInfo Format argument. 4577 * @return The text of the {@code <Default Scope Info Message>} message for {@code locale}. 4578 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 4579 */ 4580 @SuppressWarnings("unused") 4581 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 4582 private static String getDefaultScopeInfoMessage( final java.util.Locale locale, final java.lang.String scopeIdentifier, final java.lang.String classLoaderInfo ) 4583 { 4584 java.io.BufferedReader reader = null; 4585 boolean suppressExceptionOnClose = true; 4586 4587 try 4588 { 4589 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Default Scope Info Message" ), scopeIdentifier, classLoaderInfo, (Object) null ); 4590 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 4591 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 4592 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 4593 4594 String line; 4595 while ( ( line = reader.readLine() ) != null ) 4596 { 4597 builder.append( lineSeparator ).append( line ); 4598 } 4599 4600 suppressExceptionOnClose = false; 4601 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 4602 } 4603 catch( final java.lang.ClassCastException e ) 4604 { 4605 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4606 } 4607 catch( final java.lang.IllegalArgumentException e ) 4608 { 4609 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4610 } 4611 catch( final java.util.MissingResourceException e ) 4612 { 4613 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4614 } 4615 catch( final java.io.IOException e ) 4616 { 4617 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4618 } 4619 finally 4620 { 4621 try 4622 { 4623 if( reader != null ) 4624 { 4625 reader.close(); 4626 } 4627 } 4628 catch( final java.io.IOException e ) 4629 { 4630 if( !suppressExceptionOnClose ) 4631 { 4632 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4633 } 4634 } 4635 } 4636 } 4637 /** 4638 * Gets the text of the {@code <Dependency Cycle Message>} message. 4639 * <p><dl> 4640 * <dt><b>Languages:</b></dt> 4641 * <dd>English (default)</dd> 4642 * <dd>Deutsch</dd> 4643 * <dt><b>Final:</b></dt><dd>No</dd> 4644 * </dl></p> 4645 * @param locale The locale of the message to return. 4646 * @param implementationIdentifier Format argument. 4647 * @return The text of the {@code <Dependency Cycle Message>} message for {@code locale}. 4648 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 4649 */ 4650 @SuppressWarnings("unused") 4651 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 4652 private static String getDependencyCycleMessage( final java.util.Locale locale, final java.lang.String implementationIdentifier ) 4653 { 4654 java.io.BufferedReader reader = null; 4655 boolean suppressExceptionOnClose = true; 4656 4657 try 4658 { 4659 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Dependency Cycle Message" ), implementationIdentifier, (Object) null ); 4660 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 4661 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 4662 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 4663 4664 String line; 4665 while ( ( line = reader.readLine() ) != null ) 4666 { 4667 builder.append( lineSeparator ).append( line ); 4668 } 4669 4670 suppressExceptionOnClose = false; 4671 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 4672 } 4673 catch( final java.lang.ClassCastException e ) 4674 { 4675 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4676 } 4677 catch( final java.lang.IllegalArgumentException e ) 4678 { 4679 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4680 } 4681 catch( final java.util.MissingResourceException e ) 4682 { 4683 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4684 } 4685 catch( final java.io.IOException e ) 4686 { 4687 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4688 } 4689 finally 4690 { 4691 try 4692 { 4693 if( reader != null ) 4694 { 4695 reader.close(); 4696 } 4697 } 4698 catch( final java.io.IOException e ) 4699 { 4700 if( !suppressExceptionOnClose ) 4701 { 4702 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4703 } 4704 } 4705 } 4706 } 4707 /** 4708 * Gets the text of the {@code <Ignored Invocation Message>} message. 4709 * <p><dl> 4710 * <dt><b>Languages:</b></dt> 4711 * <dd>English (default)</dd> 4712 * <dd>Deutsch</dd> 4713 * <dt><b>Final:</b></dt><dd>No</dd> 4714 * </dl></p> 4715 * @param locale The locale of the message to return. 4716 * @param implementationIdentifier Format argument. 4717 * @return The text of the {@code <Ignored Invocation Message>} message for {@code locale}. 4718 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 4719 */ 4720 @SuppressWarnings("unused") 4721 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 4722 private static String getIgnoredInvocationMessage( final java.util.Locale locale, final java.lang.String implementationIdentifier ) 4723 { 4724 java.io.BufferedReader reader = null; 4725 boolean suppressExceptionOnClose = true; 4726 4727 try 4728 { 4729 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Ignored Invocation Message" ), implementationIdentifier, (Object) null ); 4730 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 4731 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 4732 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 4733 4734 String line; 4735 while ( ( line = reader.readLine() ) != null ) 4736 { 4737 builder.append( lineSeparator ).append( line ); 4738 } 4739 4740 suppressExceptionOnClose = false; 4741 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 4742 } 4743 catch( final java.lang.ClassCastException e ) 4744 { 4745 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4746 } 4747 catch( final java.lang.IllegalArgumentException e ) 4748 { 4749 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4750 } 4751 catch( final java.util.MissingResourceException e ) 4752 { 4753 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4754 } 4755 catch( final java.io.IOException e ) 4756 { 4757 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4758 } 4759 finally 4760 { 4761 try 4762 { 4763 if( reader != null ) 4764 { 4765 reader.close(); 4766 } 4767 } 4768 catch( final java.io.IOException e ) 4769 { 4770 if( !suppressExceptionOnClose ) 4771 { 4772 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4773 } 4774 } 4775 } 4776 } 4777 /** 4778 * Gets the text of the {@code <Ignored Invoker Message>} message. 4779 * <p><dl> 4780 * <dt><b>Languages:</b></dt> 4781 * <dd>English (default)</dd> 4782 * <dd>Deutsch</dd> 4783 * <dt><b>Final:</b></dt><dd>No</dd> 4784 * </dl></p> 4785 * @param locale The locale of the message to return. 4786 * @param implementationIdentifier Format argument. 4787 * @return The text of the {@code <Ignored Invoker Message>} message for {@code locale}. 4788 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 4789 */ 4790 @SuppressWarnings("unused") 4791 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 4792 private static String getIgnoredInvokerMessage( final java.util.Locale locale, final java.lang.String implementationIdentifier ) 4793 { 4794 java.io.BufferedReader reader = null; 4795 boolean suppressExceptionOnClose = true; 4796 4797 try 4798 { 4799 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Ignored Invoker Message" ), implementationIdentifier, (Object) null ); 4800 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 4801 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 4802 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 4803 4804 String line; 4805 while ( ( line = reader.readLine() ) != null ) 4806 { 4807 builder.append( lineSeparator ).append( line ); 4808 } 4809 4810 suppressExceptionOnClose = false; 4811 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 4812 } 4813 catch( final java.lang.ClassCastException e ) 4814 { 4815 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4816 } 4817 catch( final java.lang.IllegalArgumentException e ) 4818 { 4819 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4820 } 4821 catch( final java.util.MissingResourceException e ) 4822 { 4823 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4824 } 4825 catch( final java.io.IOException e ) 4826 { 4827 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4828 } 4829 finally 4830 { 4831 try 4832 { 4833 if( reader != null ) 4834 { 4835 reader.close(); 4836 } 4837 } 4838 catch( final java.io.IOException e ) 4839 { 4840 if( !suppressExceptionOnClose ) 4841 { 4842 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4843 } 4844 } 4845 } 4846 } 4847 /** 4848 * Gets the text of the {@code <Illegal Array Specification Message>} message. 4849 * <p><dl> 4850 * <dt><b>Languages:</b></dt> 4851 * <dd>English (default)</dd> 4852 * <dd>Deutsch</dd> 4853 * <dt><b>Final:</b></dt><dd>No</dd> 4854 * </dl></p> 4855 * @param locale The locale of the message to return. 4856 * @param specificationIdentifier Format argument. 4857 * @param specificationMultiplicity Format argument. 4858 * @return The text of the {@code <Illegal Array Specification Message>} message for {@code locale}. 4859 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 4860 */ 4861 @SuppressWarnings("unused") 4862 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 4863 private static String getIllegalArraySpecificationMessage( final java.util.Locale locale, final java.lang.String specificationIdentifier, final java.lang.String specificationMultiplicity ) 4864 { 4865 java.io.BufferedReader reader = null; 4866 boolean suppressExceptionOnClose = true; 4867 4868 try 4869 { 4870 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Illegal Array Specification Message" ), specificationIdentifier, specificationMultiplicity, (Object) null ); 4871 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 4872 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 4873 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 4874 4875 String line; 4876 while ( ( line = reader.readLine() ) != null ) 4877 { 4878 builder.append( lineSeparator ).append( line ); 4879 } 4880 4881 suppressExceptionOnClose = false; 4882 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 4883 } 4884 catch( final java.lang.ClassCastException e ) 4885 { 4886 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4887 } 4888 catch( final java.lang.IllegalArgumentException e ) 4889 { 4890 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4891 } 4892 catch( final java.util.MissingResourceException e ) 4893 { 4894 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4895 } 4896 catch( final java.io.IOException e ) 4897 { 4898 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4899 } 4900 finally 4901 { 4902 try 4903 { 4904 if( reader != null ) 4905 { 4906 reader.close(); 4907 } 4908 } 4909 catch( final java.io.IOException e ) 4910 { 4911 if( !suppressExceptionOnClose ) 4912 { 4913 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4914 } 4915 } 4916 } 4917 } 4918 /** 4919 * Gets the text of the {@code <Illegal Object Specification Message>} message. 4920 * <p><dl> 4921 * <dt><b>Languages:</b></dt> 4922 * <dd>English (default)</dd> 4923 * <dd>Deutsch</dd> 4924 * <dt><b>Final:</b></dt><dd>No</dd> 4925 * </dl></p> 4926 * @param locale The locale of the message to return. 4927 * @param specificationIdentifier Format argument. 4928 * @param specificationMultiplicity Format argument. 4929 * @return The text of the {@code <Illegal Object Specification Message>} message for {@code locale}. 4930 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 4931 */ 4932 @SuppressWarnings("unused") 4933 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 4934 private static String getIllegalObjectSpecificationMessage( final java.util.Locale locale, final java.lang.String specificationIdentifier, final java.lang.String specificationMultiplicity ) 4935 { 4936 java.io.BufferedReader reader = null; 4937 boolean suppressExceptionOnClose = true; 4938 4939 try 4940 { 4941 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Illegal Object Specification Message" ), specificationIdentifier, specificationMultiplicity, (Object) null ); 4942 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 4943 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 4944 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 4945 4946 String line; 4947 while ( ( line = reader.readLine() ) != null ) 4948 { 4949 builder.append( lineSeparator ).append( line ); 4950 } 4951 4952 suppressExceptionOnClose = false; 4953 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 4954 } 4955 catch( final java.lang.ClassCastException e ) 4956 { 4957 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4958 } 4959 catch( final java.lang.IllegalArgumentException e ) 4960 { 4961 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4962 } 4963 catch( final java.util.MissingResourceException e ) 4964 { 4965 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4966 } 4967 catch( final java.io.IOException e ) 4968 { 4969 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4970 } 4971 finally 4972 { 4973 try 4974 { 4975 if( reader != null ) 4976 { 4977 reader.close(); 4978 } 4979 } 4980 catch( final java.io.IOException e ) 4981 { 4982 if( !suppressExceptionOnClose ) 4983 { 4984 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 4985 } 4986 } 4987 } 4988 } 4989 /** 4990 * Gets the text of the {@code <Implementation Info Message>} message. 4991 * <p><dl> 4992 * <dt><b>Languages:</b></dt> 4993 * <dd>English (default)</dd> 4994 * <dd>Deutsch</dd> 4995 * <dt><b>Final:</b></dt><dd>No</dd> 4996 * </dl></p> 4997 * @param locale The locale of the message to return. 4998 * @param initializationMillis Format argument. 4999 * @return The text of the {@code <Implementation Info Message>} message for {@code locale}. 5000 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5001 */ 5002 @SuppressWarnings("unused") 5003 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5004 private static String getImplementationInfoMessage( final java.util.Locale locale, final java.lang.Number initializationMillis ) 5005 { 5006 java.io.BufferedReader reader = null; 5007 boolean suppressExceptionOnClose = true; 5008 5009 try 5010 { 5011 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Implementation Info Message" ), initializationMillis, (Object) null ); 5012 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 5013 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 5014 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 5015 5016 String line; 5017 while ( ( line = reader.readLine() ) != null ) 5018 { 5019 builder.append( lineSeparator ).append( line ); 5020 } 5021 5022 suppressExceptionOnClose = false; 5023 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 5024 } 5025 catch( final java.lang.ClassCastException e ) 5026 { 5027 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5028 } 5029 catch( final java.lang.IllegalArgumentException e ) 5030 { 5031 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5032 } 5033 catch( final java.util.MissingResourceException e ) 5034 { 5035 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5036 } 5037 catch( final java.io.IOException e ) 5038 { 5039 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5040 } 5041 finally 5042 { 5043 try 5044 { 5045 if( reader != null ) 5046 { 5047 reader.close(); 5048 } 5049 } 5050 catch( final java.io.IOException e ) 5051 { 5052 if( !suppressExceptionOnClose ) 5053 { 5054 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5055 } 5056 } 5057 } 5058 } 5059 /** 5060 * Gets the text of the {@code <Invoker Info Message>} message. 5061 * <p><dl> 5062 * <dt><b>Languages:</b></dt> 5063 * <dd>English (default)</dd> 5064 * <dd>Deutsch</dd> 5065 * <dt><b>Final:</b></dt><dd>No</dd> 5066 * </dl></p> 5067 * @param locale The locale of the message to return. 5068 * @param implementationIdentifier Format argument. 5069 * @param classLoaderInfo Format argument. 5070 * @return The text of the {@code <Invoker Info Message>} message for {@code locale}. 5071 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5072 */ 5073 @SuppressWarnings("unused") 5074 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5075 private static String getInvokerInfoMessage( final java.util.Locale locale, final java.lang.String implementationIdentifier, final java.lang.String classLoaderInfo ) 5076 { 5077 java.io.BufferedReader reader = null; 5078 boolean suppressExceptionOnClose = true; 5079 5080 try 5081 { 5082 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Invoker Info Message" ), implementationIdentifier, classLoaderInfo, (Object) null ); 5083 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 5084 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 5085 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 5086 5087 String line; 5088 while ( ( line = reader.readLine() ) != null ) 5089 { 5090 builder.append( lineSeparator ).append( line ); 5091 } 5092 5093 suppressExceptionOnClose = false; 5094 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 5095 } 5096 catch( final java.lang.ClassCastException e ) 5097 { 5098 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5099 } 5100 catch( final java.lang.IllegalArgumentException e ) 5101 { 5102 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5103 } 5104 catch( final java.util.MissingResourceException e ) 5105 { 5106 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5107 } 5108 catch( final java.io.IOException e ) 5109 { 5110 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5111 } 5112 finally 5113 { 5114 try 5115 { 5116 if( reader != null ) 5117 { 5118 reader.close(); 5119 } 5120 } 5121 catch( final java.io.IOException e ) 5122 { 5123 if( !suppressExceptionOnClose ) 5124 { 5125 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5126 } 5127 } 5128 } 5129 } 5130 /** 5131 * Gets the text of the {@code <Listener Info Message>} message. 5132 * <p><dl> 5133 * <dt><b>Languages:</b></dt> 5134 * <dd>English (default)</dd> 5135 * <dd>Deutsch</dd> 5136 * <dt><b>Final:</b></dt><dd>No</dd> 5137 * </dl></p> 5138 * @param locale The locale of the message to return. 5139 * @param implementationIdentifier Format argument. 5140 * @param classLoaderInfo Format argument. 5141 * @return The text of the {@code <Listener Info Message>} message for {@code locale}. 5142 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5143 */ 5144 @SuppressWarnings("unused") 5145 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5146 private static String getListenerInfoMessage( final java.util.Locale locale, final java.lang.String implementationIdentifier, final java.lang.String classLoaderInfo ) 5147 { 5148 java.io.BufferedReader reader = null; 5149 boolean suppressExceptionOnClose = true; 5150 5151 try 5152 { 5153 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Listener Info Message" ), implementationIdentifier, classLoaderInfo, (Object) null ); 5154 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 5155 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 5156 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 5157 5158 String line; 5159 while ( ( line = reader.readLine() ) != null ) 5160 { 5161 builder.append( lineSeparator ).append( line ); 5162 } 5163 5164 suppressExceptionOnClose = false; 5165 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 5166 } 5167 catch( final java.lang.ClassCastException e ) 5168 { 5169 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5170 } 5171 catch( final java.lang.IllegalArgumentException e ) 5172 { 5173 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5174 } 5175 catch( final java.util.MissingResourceException e ) 5176 { 5177 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5178 } 5179 catch( final java.io.IOException e ) 5180 { 5181 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5182 } 5183 finally 5184 { 5185 try 5186 { 5187 if( reader != null ) 5188 { 5189 reader.close(); 5190 } 5191 } 5192 catch( final java.io.IOException e ) 5193 { 5194 if( !suppressExceptionOnClose ) 5195 { 5196 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5197 } 5198 } 5199 } 5200 } 5201 /** 5202 * Gets the text of the {@code <Locator Info Message>} message. 5203 * <p><dl> 5204 * <dt><b>Languages:</b></dt> 5205 * <dd>English (default)</dd> 5206 * <dd>Deutsch</dd> 5207 * <dt><b>Final:</b></dt><dd>No</dd> 5208 * </dl></p> 5209 * @param locale The locale of the message to return. 5210 * @param implementationIdentifier Format argument. 5211 * @param schemeInfo Format argument. 5212 * @param classLoaderInfo Format argument. 5213 * @return The text of the {@code <Locator Info Message>} message for {@code locale}. 5214 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5215 */ 5216 @SuppressWarnings("unused") 5217 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5218 private static String getLocatorInfoMessage( final java.util.Locale locale, final java.lang.String implementationIdentifier, final java.lang.String schemeInfo, final java.lang.String classLoaderInfo ) 5219 { 5220 java.io.BufferedReader reader = null; 5221 boolean suppressExceptionOnClose = true; 5222 5223 try 5224 { 5225 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Locator Info Message" ), implementationIdentifier, schemeInfo, classLoaderInfo, (Object) null ); 5226 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 5227 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 5228 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 5229 5230 String line; 5231 while ( ( line = reader.readLine() ) != null ) 5232 { 5233 builder.append( lineSeparator ).append( line ); 5234 } 5235 5236 suppressExceptionOnClose = false; 5237 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 5238 } 5239 catch( final java.lang.ClassCastException e ) 5240 { 5241 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5242 } 5243 catch( final java.lang.IllegalArgumentException e ) 5244 { 5245 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5246 } 5247 catch( final java.util.MissingResourceException e ) 5248 { 5249 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5250 } 5251 catch( final java.io.IOException e ) 5252 { 5253 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5254 } 5255 finally 5256 { 5257 try 5258 { 5259 if( reader != null ) 5260 { 5261 reader.close(); 5262 } 5263 } 5264 catch( final java.io.IOException e ) 5265 { 5266 if( !suppressExceptionOnClose ) 5267 { 5268 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5269 } 5270 } 5271 } 5272 } 5273 /** 5274 * Gets the text of the {@code <Missing Dependency Message>} message. 5275 * <p><dl> 5276 * <dt><b>Languages:</b></dt> 5277 * <dd>English (default)</dd> 5278 * <dd>Deutsch</dd> 5279 * <dt><b>Final:</b></dt><dd>No</dd> 5280 * </dl></p> 5281 * @param locale The locale of the message to return. 5282 * @param implementationIdentifier Format argument. 5283 * @param dependencyName Format argument. 5284 * @return The text of the {@code <Missing Dependency Message>} message for {@code locale}. 5285 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5286 */ 5287 @SuppressWarnings("unused") 5288 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5289 private static String getMissingDependencyMessage( final java.util.Locale locale, final java.lang.String implementationIdentifier, final java.lang.String dependencyName ) 5290 { 5291 java.io.BufferedReader reader = null; 5292 boolean suppressExceptionOnClose = true; 5293 5294 try 5295 { 5296 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Missing Dependency Message" ), implementationIdentifier, dependencyName, (Object) null ); 5297 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 5298 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 5299 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 5300 5301 String line; 5302 while ( ( line = reader.readLine() ) != null ) 5303 { 5304 builder.append( lineSeparator ).append( line ); 5305 } 5306 5307 suppressExceptionOnClose = false; 5308 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 5309 } 5310 catch( final java.lang.ClassCastException e ) 5311 { 5312 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5313 } 5314 catch( final java.lang.IllegalArgumentException e ) 5315 { 5316 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5317 } 5318 catch( final java.util.MissingResourceException e ) 5319 { 5320 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5321 } 5322 catch( final java.io.IOException e ) 5323 { 5324 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5325 } 5326 finally 5327 { 5328 try 5329 { 5330 if( reader != null ) 5331 { 5332 reader.close(); 5333 } 5334 } 5335 catch( final java.io.IOException e ) 5336 { 5337 if( !suppressExceptionOnClose ) 5338 { 5339 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5340 } 5341 } 5342 } 5343 } 5344 /** 5345 * Gets the text of the {@code <Missing Implementation Message>} message. 5346 * <p><dl> 5347 * <dt><b>Languages:</b></dt> 5348 * <dd>English (default)</dd> 5349 * <dd>Deutsch</dd> 5350 * <dt><b>Final:</b></dt><dd>No</dd> 5351 * </dl></p> 5352 * @param locale The locale of the message to return. 5353 * @param specificationIdentifier Format argument. 5354 * @param implementationName Format argument. 5355 * @return The text of the {@code <Missing Implementation Message>} message for {@code locale}. 5356 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5357 */ 5358 @SuppressWarnings("unused") 5359 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5360 private static String getMissingImplementationMessage( final java.util.Locale locale, final java.lang.String specificationIdentifier, final java.lang.String implementationName ) 5361 { 5362 java.io.BufferedReader reader = null; 5363 boolean suppressExceptionOnClose = true; 5364 5365 try 5366 { 5367 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Missing Implementation Message" ), specificationIdentifier, implementationName, (Object) null ); 5368 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 5369 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 5370 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 5371 5372 String line; 5373 while ( ( line = reader.readLine() ) != null ) 5374 { 5375 builder.append( lineSeparator ).append( line ); 5376 } 5377 5378 suppressExceptionOnClose = false; 5379 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 5380 } 5381 catch( final java.lang.ClassCastException e ) 5382 { 5383 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5384 } 5385 catch( final java.lang.IllegalArgumentException e ) 5386 { 5387 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5388 } 5389 catch( final java.util.MissingResourceException e ) 5390 { 5391 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5392 } 5393 catch( final java.io.IOException e ) 5394 { 5395 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5396 } 5397 finally 5398 { 5399 try 5400 { 5401 if( reader != null ) 5402 { 5403 reader.close(); 5404 } 5405 } 5406 catch( final java.io.IOException e ) 5407 { 5408 if( !suppressExceptionOnClose ) 5409 { 5410 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5411 } 5412 } 5413 } 5414 } 5415 /** 5416 * Gets the text of the {@code <Missing Implementations Message>} message. 5417 * <p><dl> 5418 * <dt><b>Languages:</b></dt> 5419 * <dd>English (default)</dd> 5420 * <dd>Deutsch</dd> 5421 * <dt><b>Final:</b></dt><dd>No</dd> 5422 * </dl></p> 5423 * @param locale The locale of the message to return. 5424 * @param specificationIdentifier Format argument. 5425 * @return The text of the {@code <Missing Implementations Message>} message for {@code locale}. 5426 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5427 */ 5428 @SuppressWarnings("unused") 5429 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5430 private static String getMissingImplementationsMessage( final java.util.Locale locale, final java.lang.String specificationIdentifier ) 5431 { 5432 java.io.BufferedReader reader = null; 5433 boolean suppressExceptionOnClose = true; 5434 5435 try 5436 { 5437 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Missing Implementations Message" ), specificationIdentifier, (Object) null ); 5438 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 5439 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 5440 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 5441 5442 String line; 5443 while ( ( line = reader.readLine() ) != null ) 5444 { 5445 builder.append( lineSeparator ).append( line ); 5446 } 5447 5448 suppressExceptionOnClose = false; 5449 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 5450 } 5451 catch( final java.lang.ClassCastException e ) 5452 { 5453 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5454 } 5455 catch( final java.lang.IllegalArgumentException e ) 5456 { 5457 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5458 } 5459 catch( final java.util.MissingResourceException e ) 5460 { 5461 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5462 } 5463 catch( final java.io.IOException e ) 5464 { 5465 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5466 } 5467 finally 5468 { 5469 try 5470 { 5471 if( reader != null ) 5472 { 5473 reader.close(); 5474 } 5475 } 5476 catch( final java.io.IOException e ) 5477 { 5478 if( !suppressExceptionOnClose ) 5479 { 5480 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5481 } 5482 } 5483 } 5484 } 5485 /** 5486 * Gets the text of the {@code <Missing Instance Message>} message. 5487 * <p><dl> 5488 * <dt><b>Languages:</b></dt> 5489 * <dd>English (default)</dd> 5490 * <dd>Deutsch</dd> 5491 * <dt><b>Final:</b></dt><dd>No</dd> 5492 * </dl></p> 5493 * @param locale The locale of the message to return. 5494 * @param implementationIdentifier Format argument. 5495 * @param implementationName Format argument. 5496 * @return The text of the {@code <Missing Instance Message>} message for {@code locale}. 5497 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5498 */ 5499 @SuppressWarnings("unused") 5500 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5501 private static String getMissingInstanceMessage( final java.util.Locale locale, final java.lang.String implementationIdentifier, final java.lang.String implementationName ) 5502 { 5503 java.io.BufferedReader reader = null; 5504 boolean suppressExceptionOnClose = true; 5505 5506 try 5507 { 5508 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Missing Instance Message" ), implementationIdentifier, implementationName, (Object) null ); 5509 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 5510 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 5511 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 5512 5513 String line; 5514 while ( ( line = reader.readLine() ) != null ) 5515 { 5516 builder.append( lineSeparator ).append( line ); 5517 } 5518 5519 suppressExceptionOnClose = false; 5520 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 5521 } 5522 catch( final java.lang.ClassCastException e ) 5523 { 5524 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5525 } 5526 catch( final java.lang.IllegalArgumentException e ) 5527 { 5528 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5529 } 5530 catch( final java.util.MissingResourceException e ) 5531 { 5532 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5533 } 5534 catch( final java.io.IOException e ) 5535 { 5536 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5537 } 5538 finally 5539 { 5540 try 5541 { 5542 if( reader != null ) 5543 { 5544 reader.close(); 5545 } 5546 } 5547 catch( final java.io.IOException e ) 5548 { 5549 if( !suppressExceptionOnClose ) 5550 { 5551 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5552 } 5553 } 5554 } 5555 } 5556 /** 5557 * Gets the text of the {@code <Missing Locator Message>} message. 5558 * <p><dl> 5559 * <dt><b>Languages:</b></dt> 5560 * <dd>English (default)</dd> 5561 * <dd>Deutsch</dd> 5562 * <dt><b>Final:</b></dt><dd>No</dd> 5563 * </dl></p> 5564 * @param locale The locale of the message to return. 5565 * @param locationInfo Format argument. 5566 * @return The text of the {@code <Missing Locator Message>} message for {@code locale}. 5567 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5568 */ 5569 @SuppressWarnings("unused") 5570 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5571 private static String getMissingLocatorMessage( final java.util.Locale locale, final java.lang.String locationInfo ) 5572 { 5573 java.io.BufferedReader reader = null; 5574 boolean suppressExceptionOnClose = true; 5575 5576 try 5577 { 5578 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Missing Locator Message" ), locationInfo, (Object) null ); 5579 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 5580 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 5581 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 5582 5583 String line; 5584 while ( ( line = reader.readLine() ) != null ) 5585 { 5586 builder.append( lineSeparator ).append( line ); 5587 } 5588 5589 suppressExceptionOnClose = false; 5590 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 5591 } 5592 catch( final java.lang.ClassCastException e ) 5593 { 5594 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5595 } 5596 catch( final java.lang.IllegalArgumentException e ) 5597 { 5598 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5599 } 5600 catch( final java.util.MissingResourceException e ) 5601 { 5602 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5603 } 5604 catch( final java.io.IOException e ) 5605 { 5606 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5607 } 5608 finally 5609 { 5610 try 5611 { 5612 if( reader != null ) 5613 { 5614 reader.close(); 5615 } 5616 } 5617 catch( final java.io.IOException e ) 5618 { 5619 if( !suppressExceptionOnClose ) 5620 { 5621 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5622 } 5623 } 5624 } 5625 } 5626 /** 5627 * Gets the text of the {@code <Missing Message Message>} message. 5628 * <p><dl> 5629 * <dt><b>Languages:</b></dt> 5630 * <dd>English (default)</dd> 5631 * <dd>Deutsch</dd> 5632 * <dt><b>Final:</b></dt><dd>No</dd> 5633 * </dl></p> 5634 * @param locale The locale of the message to return. 5635 * @param implementationIdentifier Format argument. 5636 * @param messageName Format argument. 5637 * @return The text of the {@code <Missing Message Message>} message for {@code locale}. 5638 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5639 */ 5640 @SuppressWarnings("unused") 5641 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5642 private static String getMissingMessageMessage( final java.util.Locale locale, final java.lang.String implementationIdentifier, final java.lang.String messageName ) 5643 { 5644 java.io.BufferedReader reader = null; 5645 boolean suppressExceptionOnClose = true; 5646 5647 try 5648 { 5649 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Missing Message Message" ), implementationIdentifier, messageName, (Object) null ); 5650 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 5651 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 5652 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 5653 5654 String line; 5655 while ( ( line = reader.readLine() ) != null ) 5656 { 5657 builder.append( lineSeparator ).append( line ); 5658 } 5659 5660 suppressExceptionOnClose = false; 5661 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 5662 } 5663 catch( final java.lang.ClassCastException e ) 5664 { 5665 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5666 } 5667 catch( final java.lang.IllegalArgumentException e ) 5668 { 5669 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5670 } 5671 catch( final java.util.MissingResourceException e ) 5672 { 5673 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5674 } 5675 catch( final java.io.IOException e ) 5676 { 5677 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5678 } 5679 finally 5680 { 5681 try 5682 { 5683 if( reader != null ) 5684 { 5685 reader.close(); 5686 } 5687 } 5688 catch( final java.io.IOException e ) 5689 { 5690 if( !suppressExceptionOnClose ) 5691 { 5692 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5693 } 5694 } 5695 } 5696 } 5697 /** 5698 * Gets the text of the {@code <Missing Object Instance Message>} message. 5699 * <p><dl> 5700 * <dt><b>Languages:</b></dt> 5701 * <dd>English (default)</dd> 5702 * <dd>Deutsch</dd> 5703 * <dt><b>Final:</b></dt><dd>No</dd> 5704 * </dl></p> 5705 * @param locale The locale of the message to return. 5706 * @param objectInfo Format argument. 5707 * @return The text of the {@code <Missing Object Instance Message>} message for {@code locale}. 5708 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5709 */ 5710 @SuppressWarnings("unused") 5711 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5712 private static String getMissingObjectInstanceMessage( final java.util.Locale locale, final java.lang.String objectInfo ) 5713 { 5714 java.io.BufferedReader reader = null; 5715 boolean suppressExceptionOnClose = true; 5716 5717 try 5718 { 5719 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Missing Object Instance Message" ), objectInfo, (Object) null ); 5720 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 5721 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 5722 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 5723 5724 String line; 5725 while ( ( line = reader.readLine() ) != null ) 5726 { 5727 builder.append( lineSeparator ).append( line ); 5728 } 5729 5730 suppressExceptionOnClose = false; 5731 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 5732 } 5733 catch( final java.lang.ClassCastException e ) 5734 { 5735 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5736 } 5737 catch( final java.lang.IllegalArgumentException e ) 5738 { 5739 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5740 } 5741 catch( final java.util.MissingResourceException e ) 5742 { 5743 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5744 } 5745 catch( final java.io.IOException e ) 5746 { 5747 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5748 } 5749 finally 5750 { 5751 try 5752 { 5753 if( reader != null ) 5754 { 5755 reader.close(); 5756 } 5757 } 5758 catch( final java.io.IOException e ) 5759 { 5760 if( !suppressExceptionOnClose ) 5761 { 5762 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5763 } 5764 } 5765 } 5766 } 5767 /** 5768 * Gets the text of the {@code <Missing Object Message>} message. 5769 * <p><dl> 5770 * <dt><b>Languages:</b></dt> 5771 * <dd>English (default)</dd> 5772 * <dd>Deutsch</dd> 5773 * <dt><b>Final:</b></dt><dd>No</dd> 5774 * </dl></p> 5775 * @param locale The locale of the message to return. 5776 * @param implementationIdentifier Format argument. 5777 * @param implementationName Format argument. 5778 * @return The text of the {@code <Missing Object Message>} message for {@code locale}. 5779 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5780 */ 5781 @SuppressWarnings("unused") 5782 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5783 private static String getMissingObjectMessage( final java.util.Locale locale, final java.lang.String implementationIdentifier, final java.lang.String implementationName ) 5784 { 5785 java.io.BufferedReader reader = null; 5786 boolean suppressExceptionOnClose = true; 5787 5788 try 5789 { 5790 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Missing Object Message" ), implementationIdentifier, implementationName, (Object) null ); 5791 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 5792 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 5793 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 5794 5795 String line; 5796 while ( ( line = reader.readLine() ) != null ) 5797 { 5798 builder.append( lineSeparator ).append( line ); 5799 } 5800 5801 suppressExceptionOnClose = false; 5802 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 5803 } 5804 catch( final java.lang.ClassCastException e ) 5805 { 5806 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5807 } 5808 catch( final java.lang.IllegalArgumentException e ) 5809 { 5810 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5811 } 5812 catch( final java.util.MissingResourceException e ) 5813 { 5814 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5815 } 5816 catch( final java.io.IOException e ) 5817 { 5818 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5819 } 5820 finally 5821 { 5822 try 5823 { 5824 if( reader != null ) 5825 { 5826 reader.close(); 5827 } 5828 } 5829 catch( final java.io.IOException e ) 5830 { 5831 if( !suppressExceptionOnClose ) 5832 { 5833 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5834 } 5835 } 5836 } 5837 } 5838 /** 5839 * Gets the text of the {@code <Missing Property Message>} message. 5840 * <p><dl> 5841 * <dt><b>Languages:</b></dt> 5842 * <dd>English (default)</dd> 5843 * <dd>Deutsch</dd> 5844 * <dt><b>Final:</b></dt><dd>No</dd> 5845 * </dl></p> 5846 * @param locale The locale of the message to return. 5847 * @param implementationIdentifier Format argument. 5848 * @param propertyName Format argument. 5849 * @return The text of the {@code <Missing Property Message>} message for {@code locale}. 5850 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5851 */ 5852 @SuppressWarnings("unused") 5853 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5854 private static String getMissingPropertyMessage( final java.util.Locale locale, final java.lang.String implementationIdentifier, final java.lang.String propertyName ) 5855 { 5856 java.io.BufferedReader reader = null; 5857 boolean suppressExceptionOnClose = true; 5858 5859 try 5860 { 5861 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Missing Property Message" ), implementationIdentifier, propertyName, (Object) null ); 5862 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 5863 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 5864 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 5865 5866 String line; 5867 while ( ( line = reader.readLine() ) != null ) 5868 { 5869 builder.append( lineSeparator ).append( line ); 5870 } 5871 5872 suppressExceptionOnClose = false; 5873 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 5874 } 5875 catch( final java.lang.ClassCastException e ) 5876 { 5877 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5878 } 5879 catch( final java.lang.IllegalArgumentException e ) 5880 { 5881 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5882 } 5883 catch( final java.util.MissingResourceException e ) 5884 { 5885 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5886 } 5887 catch( final java.io.IOException e ) 5888 { 5889 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5890 } 5891 finally 5892 { 5893 try 5894 { 5895 if( reader != null ) 5896 { 5897 reader.close(); 5898 } 5899 } 5900 catch( final java.io.IOException e ) 5901 { 5902 if( !suppressExceptionOnClose ) 5903 { 5904 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5905 } 5906 } 5907 } 5908 } 5909 /** 5910 * Gets the text of the {@code <Missing Scope Message>} message. 5911 * <p><dl> 5912 * <dt><b>Languages:</b></dt> 5913 * <dd>English (default)</dd> 5914 * <dd>Deutsch</dd> 5915 * <dt><b>Final:</b></dt><dd>No</dd> 5916 * </dl></p> 5917 * @param locale The locale of the message to return. 5918 * @param scopeIdentifier Format argument. 5919 * @return The text of the {@code <Missing Scope Message>} message for {@code locale}. 5920 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5921 */ 5922 @SuppressWarnings("unused") 5923 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5924 private static String getMissingScopeMessage( final java.util.Locale locale, final java.lang.String scopeIdentifier ) 5925 { 5926 java.io.BufferedReader reader = null; 5927 boolean suppressExceptionOnClose = true; 5928 5929 try 5930 { 5931 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Missing Scope Message" ), scopeIdentifier, (Object) null ); 5932 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 5933 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 5934 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 5935 5936 String line; 5937 while ( ( line = reader.readLine() ) != null ) 5938 { 5939 builder.append( lineSeparator ).append( line ); 5940 } 5941 5942 suppressExceptionOnClose = false; 5943 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 5944 } 5945 catch( final java.lang.ClassCastException e ) 5946 { 5947 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5948 } 5949 catch( final java.lang.IllegalArgumentException e ) 5950 { 5951 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5952 } 5953 catch( final java.util.MissingResourceException e ) 5954 { 5955 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5956 } 5957 catch( final java.io.IOException e ) 5958 { 5959 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5960 } 5961 finally 5962 { 5963 try 5964 { 5965 if( reader != null ) 5966 { 5967 reader.close(); 5968 } 5969 } 5970 catch( final java.io.IOException e ) 5971 { 5972 if( !suppressExceptionOnClose ) 5973 { 5974 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 5975 } 5976 } 5977 } 5978 } 5979 /** 5980 * Gets the text of the {@code <Missing Specification Class Message>} message. 5981 * <p><dl> 5982 * <dt><b>Languages:</b></dt> 5983 * <dd>English (default)</dd> 5984 * <dd>Deutsch</dd> 5985 * <dt><b>Final:</b></dt><dd>No</dd> 5986 * </dl></p> 5987 * @param locale The locale of the message to return. 5988 * @param specificationIdentifier Format argument. 5989 * @return The text of the {@code <Missing Specification Class Message>} message for {@code locale}. 5990 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 5991 */ 5992 @SuppressWarnings("unused") 5993 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 5994 private static String getMissingSpecificationClassMessage( final java.util.Locale locale, final java.lang.String specificationIdentifier ) 5995 { 5996 java.io.BufferedReader reader = null; 5997 boolean suppressExceptionOnClose = true; 5998 5999 try 6000 { 6001 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Missing Specification Class Message" ), specificationIdentifier, (Object) null ); 6002 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 6003 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 6004 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 6005 6006 String line; 6007 while ( ( line = reader.readLine() ) != null ) 6008 { 6009 builder.append( lineSeparator ).append( line ); 6010 } 6011 6012 suppressExceptionOnClose = false; 6013 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 6014 } 6015 catch( final java.lang.ClassCastException e ) 6016 { 6017 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6018 } 6019 catch( final java.lang.IllegalArgumentException e ) 6020 { 6021 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6022 } 6023 catch( final java.util.MissingResourceException e ) 6024 { 6025 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6026 } 6027 catch( final java.io.IOException e ) 6028 { 6029 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6030 } 6031 finally 6032 { 6033 try 6034 { 6035 if( reader != null ) 6036 { 6037 reader.close(); 6038 } 6039 } 6040 catch( final java.io.IOException e ) 6041 { 6042 if( !suppressExceptionOnClose ) 6043 { 6044 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6045 } 6046 } 6047 } 6048 } 6049 /** 6050 * Gets the text of the {@code <Missing Specification Message>} message. 6051 * <p><dl> 6052 * <dt><b>Languages:</b></dt> 6053 * <dd>English (default)</dd> 6054 * <dd>Deutsch</dd> 6055 * <dt><b>Final:</b></dt><dd>No</dd> 6056 * </dl></p> 6057 * @param locale The locale of the message to return. 6058 * @param specificationIdentifier Format argument. 6059 * @return The text of the {@code <Missing Specification Message>} message for {@code locale}. 6060 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 6061 */ 6062 @SuppressWarnings("unused") 6063 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 6064 private static String getMissingSpecificationMessage( final java.util.Locale locale, final java.lang.String specificationIdentifier ) 6065 { 6066 java.io.BufferedReader reader = null; 6067 boolean suppressExceptionOnClose = true; 6068 6069 try 6070 { 6071 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Missing Specification Message" ), specificationIdentifier, (Object) null ); 6072 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 6073 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 6074 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 6075 6076 String line; 6077 while ( ( line = reader.readLine() ) != null ) 6078 { 6079 builder.append( lineSeparator ).append( line ); 6080 } 6081 6082 suppressExceptionOnClose = false; 6083 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 6084 } 6085 catch( final java.lang.ClassCastException e ) 6086 { 6087 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6088 } 6089 catch( final java.lang.IllegalArgumentException e ) 6090 { 6091 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6092 } 6093 catch( final java.util.MissingResourceException e ) 6094 { 6095 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6096 } 6097 catch( final java.io.IOException e ) 6098 { 6099 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6100 } 6101 finally 6102 { 6103 try 6104 { 6105 if( reader != null ) 6106 { 6107 reader.close(); 6108 } 6109 } 6110 catch( final java.io.IOException e ) 6111 { 6112 if( !suppressExceptionOnClose ) 6113 { 6114 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6115 } 6116 } 6117 } 6118 } 6119 /** 6120 * Gets the text of the {@code <Modules Report Message>} message. 6121 * <p><dl> 6122 * <dt><b>Languages:</b></dt> 6123 * <dd>English (default)</dd> 6124 * <dd>Deutsch</dd> 6125 * <dt><b>Final:</b></dt><dd>No</dd> 6126 * </dl></p> 6127 * @param locale The locale of the message to return. 6128 * @return The text of the {@code <Modules Report Message>} message for {@code locale}. 6129 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 6130 */ 6131 @SuppressWarnings("unused") 6132 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 6133 private static String getModulesReportMessage( final java.util.Locale locale ) 6134 { 6135 java.io.BufferedReader reader = null; 6136 boolean suppressExceptionOnClose = true; 6137 6138 try 6139 { 6140 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Modules Report Message" ), (Object) null ); 6141 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 6142 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 6143 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 6144 6145 String line; 6146 while ( ( line = reader.readLine() ) != null ) 6147 { 6148 builder.append( lineSeparator ).append( line ); 6149 } 6150 6151 suppressExceptionOnClose = false; 6152 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 6153 } 6154 catch( final java.lang.ClassCastException e ) 6155 { 6156 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6157 } 6158 catch( final java.lang.IllegalArgumentException e ) 6159 { 6160 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6161 } 6162 catch( final java.util.MissingResourceException e ) 6163 { 6164 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6165 } 6166 catch( final java.io.IOException e ) 6167 { 6168 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6169 } 6170 finally 6171 { 6172 try 6173 { 6174 if( reader != null ) 6175 { 6176 reader.close(); 6177 } 6178 } 6179 catch( final java.io.IOException e ) 6180 { 6181 if( !suppressExceptionOnClose ) 6182 { 6183 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6184 } 6185 } 6186 } 6187 } 6188 /** 6189 * Gets the text of the {@code <Scope Contention Failure>} message. 6190 * <p><dl> 6191 * <dt><b>Languages:</b></dt> 6192 * <dd>English (default)</dd> 6193 * <dd>Deutsch</dd> 6194 * <dt><b>Final:</b></dt><dd>No</dd> 6195 * </dl></p> 6196 * @param locale The locale of the message to return. 6197 * @param objectIdentifier Format argument. 6198 * @return The text of the {@code <Scope Contention Failure>} message for {@code locale}. 6199 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 6200 */ 6201 @SuppressWarnings("unused") 6202 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 6203 private static String getScopeContentionFailure( final java.util.Locale locale, final java.lang.String objectIdentifier ) 6204 { 6205 java.io.BufferedReader reader = null; 6206 boolean suppressExceptionOnClose = true; 6207 6208 try 6209 { 6210 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Scope Contention Failure" ), objectIdentifier, (Object) null ); 6211 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 6212 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 6213 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 6214 6215 String line; 6216 while ( ( line = reader.readLine() ) != null ) 6217 { 6218 builder.append( lineSeparator ).append( line ); 6219 } 6220 6221 suppressExceptionOnClose = false; 6222 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 6223 } 6224 catch( final java.lang.ClassCastException e ) 6225 { 6226 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6227 } 6228 catch( final java.lang.IllegalArgumentException e ) 6229 { 6230 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6231 } 6232 catch( final java.util.MissingResourceException e ) 6233 { 6234 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6235 } 6236 catch( final java.io.IOException e ) 6237 { 6238 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6239 } 6240 finally 6241 { 6242 try 6243 { 6244 if( reader != null ) 6245 { 6246 reader.close(); 6247 } 6248 } 6249 catch( final java.io.IOException e ) 6250 { 6251 if( !suppressExceptionOnClose ) 6252 { 6253 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6254 } 6255 } 6256 } 6257 } 6258 /** 6259 * Gets the text of the {@code <Scope Info Message>} message. 6260 * <p><dl> 6261 * <dt><b>Languages:</b></dt> 6262 * <dd>English (default)</dd> 6263 * <dd>Deutsch</dd> 6264 * <dt><b>Final:</b></dt><dd>No</dd> 6265 * </dl></p> 6266 * @param locale The locale of the message to return. 6267 * @param implementationIdentifier Format argument. 6268 * @param scopeIdentifier Format argument. 6269 * @param classLoaderInfo Format argument. 6270 * @return The text of the {@code <Scope Info Message>} message for {@code locale}. 6271 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 6272 */ 6273 @SuppressWarnings("unused") 6274 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 6275 private static String getScopeInfoMessage( final java.util.Locale locale, final java.lang.String implementationIdentifier, final java.lang.String scopeIdentifier, final java.lang.String classLoaderInfo ) 6276 { 6277 java.io.BufferedReader reader = null; 6278 boolean suppressExceptionOnClose = true; 6279 6280 try 6281 { 6282 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Scope Info Message" ), implementationIdentifier, scopeIdentifier, classLoaderInfo, (Object) null ); 6283 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 6284 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 6285 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 6286 6287 String line; 6288 while ( ( line = reader.readLine() ) != null ) 6289 { 6290 builder.append( lineSeparator ).append( line ); 6291 } 6292 6293 suppressExceptionOnClose = false; 6294 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 6295 } 6296 catch( final java.lang.ClassCastException e ) 6297 { 6298 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6299 } 6300 catch( final java.lang.IllegalArgumentException e ) 6301 { 6302 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6303 } 6304 catch( final java.util.MissingResourceException e ) 6305 { 6306 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6307 } 6308 catch( final java.io.IOException e ) 6309 { 6310 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6311 } 6312 finally 6313 { 6314 try 6315 { 6316 if( reader != null ) 6317 { 6318 reader.close(); 6319 } 6320 } 6321 catch( final java.io.IOException e ) 6322 { 6323 if( !suppressExceptionOnClose ) 6324 { 6325 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6326 } 6327 } 6328 } 6329 } 6330 /** 6331 * Gets the text of the {@code <Unexpected Dependency Objects Message>} message. 6332 * <p><dl> 6333 * <dt><b>Languages:</b></dt> 6334 * <dd>English (default)</dd> 6335 * <dd>Deutsch</dd> 6336 * <dt><b>Final:</b></dt><dd>No</dd> 6337 * </dl></p> 6338 * @param locale The locale of the message to return. 6339 * @param implementationIdentifier Format argument. 6340 * @param dependencyName Format argument. 6341 * @param expectedNumber Format argument. 6342 * @param computedNumber Format argument. 6343 * @return The text of the {@code <Unexpected Dependency Objects Message>} message for {@code locale}. 6344 * @throws org.jomc.ObjectManagementException if getting the message instance fails. 6345 */ 6346 @SuppressWarnings("unused") 6347 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.4", comments = "See http://www.jomc.org/jomc/1.4/jomc-tools-1.4" ) 6348 private static String getUnexpectedDependencyObjectsMessage( final java.util.Locale locale, final java.lang.String implementationIdentifier, final java.lang.String dependencyName, final java.lang.Number expectedNumber, final java.lang.Number computedNumber ) 6349 { 6350 java.io.BufferedReader reader = null; 6351 boolean suppressExceptionOnClose = true; 6352 6353 try 6354 { 6355 final String message = java.text.MessageFormat.format( java.util.ResourceBundle.getBundle( "org.jomc.ri.DefaultObjectManager", locale ).getString( "Unexpected Dependency Objects Message" ), implementationIdentifier, dependencyName, expectedNumber, computedNumber, (Object) null ); 6356 final java.lang.StringBuilder builder = new java.lang.StringBuilder( message.length() ); 6357 reader = new java.io.BufferedReader( new java.io.StringReader( message ) ); 6358 final String lineSeparator = System.getProperty( "line.separator", "\n" ); 6359 6360 String line; 6361 while ( ( line = reader.readLine() ) != null ) 6362 { 6363 builder.append( lineSeparator ).append( line ); 6364 } 6365 6366 suppressExceptionOnClose = false; 6367 return builder.length() > 0 ? builder.substring( lineSeparator.length() ) : ""; 6368 } 6369 catch( final java.lang.ClassCastException e ) 6370 { 6371 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6372 } 6373 catch( final java.lang.IllegalArgumentException e ) 6374 { 6375 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6376 } 6377 catch( final java.util.MissingResourceException e ) 6378 { 6379 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6380 } 6381 catch( final java.io.IOException e ) 6382 { 6383 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6384 } 6385 finally 6386 { 6387 try 6388 { 6389 if( reader != null ) 6390 { 6391 reader.close(); 6392 } 6393 } 6394 catch( final java.io.IOException e ) 6395 { 6396 if( !suppressExceptionOnClose ) 6397 { 6398 throw new org.jomc.ObjectManagementException( e.getMessage(), e ); 6399 } 6400 } 6401 } 6402 } 6403 // </editor-fold> 6404 // SECTION-END 6405}