View Javadoc

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