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