1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
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
115
116 public class DefaultObjectManager implements ObjectManager
117 {
118
119
120
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
125 super();
126
127 }
128
129
130
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
952
953
954 protected static final String SINGLETON_SCOPE_IDENTIFIER = "Singleton";
955
956
957
958
959
960 private static final Class<?>[] INVOCATION_HANDLER_ARGUMENTS =
961 {
962 InvocationHandler.class
963 };
964
965
966
967
968
969 private static final Level DEFAULT_LOG_LEVEL = Level.WARNING;
970
971
972 private static volatile Level defaultLogLevel;
973
974
975 private static volatile String bootstrapClassLoaderClassName;
976
977 private static volatile boolean bootstrapClassLoaderClassNameInitialized;
978
979
980
981
982
983 private static volatile String defaultModelIdentifier;
984
985
986
987
988
989 private String modelIdentifier;
990
991
992
993
994
995 private static volatile Boolean defaultModelObjectClasspathResolutionEnabled;
996
997
998
999
1000
1001 private Boolean modelObjectClasspathResolutionEnabled;
1002
1003
1004
1005
1006
1007 private static volatile Boolean defaultModelProcessingEnabled;
1008
1009
1010
1011
1012
1013 private Boolean modelProcessingEnabled;
1014
1015
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
1030 private boolean initialized;
1031
1032
1033 private Level logLevel;
1034
1035
1036 private final Map<ClassLoader, List<Listener>> listeners =
1037 new WeakIdentityHashMap<ClassLoader, List<Listener>>();
1038
1039
1040 private final Map<ClassLoader, Modules> modules =
1041 new WeakIdentityHashMap<ClassLoader, Modules>();
1042
1043
1044 private final Map<ClassLoader, Invoker> invokers =
1045 new WeakIdentityHashMap<ClassLoader, Invoker>();
1046
1047
1048 private final Map<ClassLoader, Map<String, Scope>> scopes =
1049 new WeakIdentityHashMap<ClassLoader, Map<String, Scope>>();
1050
1051
1052 private final Map<ClassLoader, Map<String, Locator>> locators =
1053 new WeakIdentityHashMap<ClassLoader, Map<String, Locator>>();
1054
1055
1056 private final Map<ClassLoader, Map<Object, Instance>> objects =
1057 new WeakIdentityHashMap<ClassLoader, Map<Object, Instance>>();
1058
1059
1060 private static final Map<ClassLoader, ObjectManager> singletons =
1061 new WeakIdentityHashMap<ClassLoader, ObjectManager>();
1062
1063
1064
1065
1066
1067 private static final Map<ClassLoader, Reference<ClassLoader>> defaultClassLoaders =
1068 new WeakIdentityHashMap<ClassLoader, Reference<ClassLoader>>();
1069
1070
1071
1072
1073
1074 private static final Map<ClassLoader, Map<String, Reference<Constructor<?>>>> proxyClassConstructors =
1075 new WeakIdentityHashMap<ClassLoader, Map<String, Reference<Constructor<?>>>>();
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
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
1105
1106
1107
1108
1109
1110
1111
1112 public List<Listener> getListeners()
1113 {
1114 return this.getListeners( this.getDefaultClassLoader( this.getClass() ) );
1115 }
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
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
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268 @Deprecated
1269 public Listener getDefaultListener()
1270 {
1271 return new DefaultListener();
1272 }
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
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
1302
1303
1304
1305
1306
1307
1308
1309
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
1325
1326
1327
1328
1329
1330 public static void setDefaultLogLevel( final Level value )
1331 {
1332 defaultLogLevel = value;
1333 }
1334
1335
1336
1337
1338
1339
1340
1341
1342
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
1363
1364
1365
1366
1367
1368
1369 public final void setLogLevel( final Level value )
1370 {
1371 this.logLevel = value;
1372 }
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
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
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
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
1419
1420
1421
1422
1423
1424
1425
1426
1427
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
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
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
1479
1480
1481
1482
1483
1484
1485
1486 public static void setDefaultModelIdentifier( final String value )
1487 {
1488 defaultModelIdentifier = value;
1489 }
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
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
1520
1521
1522
1523
1524
1525 public final void setModelIdentifier( final String value )
1526 {
1527 this.modelIdentifier = value;
1528 }
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
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
1560
1561
1562
1563
1564
1565
1566
1567
1568 public static void setDefaultModelObjectClasspathResolutionEnabled( final Boolean value )
1569 {
1570 defaultModelObjectClasspathResolutionEnabled = value;
1571 }
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
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
1603
1604
1605
1606
1607
1608
1609
1610 public final void setModelObjectClasspathResolutionEnabled( final Boolean value )
1611 {
1612 this.modelObjectClasspathResolutionEnabled = value;
1613 }
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
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
1643
1644
1645
1646
1647
1648
1649
1650 public static void setDefaultModelProcessingEnabled( final Boolean value )
1651 {
1652 defaultModelProcessingEnabled = value;
1653 }
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
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
1684
1685
1686
1687
1688
1689
1690
1691 public final void setModelProcessingEnabled( final Boolean value )
1692 {
1693 this.modelProcessingEnabled = value;
1694 }
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
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
1722
1723
1724
1725
1726
1727 public static void setBootstrapClassLoaderClassName( final String value )
1728 {
1729 bootstrapClassLoaderClassName = value;
1730 bootstrapClassLoaderClassNameInitialized = false;
1731 }
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
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
1875
1876
1877
1878
1879
1880
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
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
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
1975
1976
1977
1978
1979
1980
1981
1982
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
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
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
2060
2061
2062
2063
2064
2065
2066
2067
2068
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
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
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
2149
2150
2151
2152
2153
2154
2155
2156
2157
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
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
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
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
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
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
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
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
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
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
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
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
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
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
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
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
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
2638
2639
2640
2641
2642
2643
2644
2645
2646
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
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745
2746 @Deprecated
2747 public Invoker getDefaultInvoker()
2748 {
2749 return new DefaultInvoker();
2750 }
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
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
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
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
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
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
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914 @Deprecated
2915 public Invocation getDefaultInvocation()
2916 {
2917 return new DefaultInvocation();
2918 }
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
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
2947
2948
2949
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
3053
3054
3055
3056
3057
3058
3059
3060
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
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452
3453
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
3513
3514
3515
3516
3517
3518
3519
3520
3521
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
3581
3582
3583
3584
3585
3586
3587
3588
3589
3590
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
3650
3651
3652
3653
3654
3655
3656
3657
3658
3659
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
3719
3720
3721
3722
3723
3724
3725
3726
3727
3728
3729
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
3789
3790
3791
3792
3793
3794
3795
3796
3797
3798
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
3858
3859
3860
3861
3862
3863
3864
3865
3866
3867
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
3927
3928
3929
3930
3931
3932
3933
3934
3935
3936
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
3996
3997
3998
3999
4000
4001
4002
4003
4004
4005
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
4065
4066
4067
4068
4069
4070
4071
4072
4073
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
4133
4134
4135
4136
4137
4138
4139
4140
4141
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
4201
4202
4203
4204
4205
4206
4207
4208
4209
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
4269
4270
4271
4272
4273
4274
4275
4276
4277
4278
4279
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
4339
4340
4341
4342
4343
4344
4345
4346
4347
4348
4349
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
4409
4410
4411
4412
4413
4414
4415
4416
4417
4418
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
4478
4479
4480
4481
4482
4483
4484
4485
4486
4487
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
4547
4548
4549
4550
4551
4552
4553
4554
4555
4556
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
4616
4617
4618
4619
4620
4621
4622
4623
4624
4625
4626
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
4686
4687
4688
4689
4690
4691
4692
4693
4694
4695
4696
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
4756
4757
4758
4759
4760
4761
4762
4763
4764
4765
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
4825
4826
4827
4828
4829
4830
4831
4832
4833
4834
4835
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
4895
4896
4897
4898
4899
4900
4901
4902
4903
4904
4905
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
4965
4966
4967
4968
4969
4970
4971
4972
4973
4974
4975
4976
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
5036
5037
5038
5039
5040
5041
5042
5043
5044
5045
5046
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
5106
5107
5108
5109
5110
5111
5112
5113
5114
5115
5116
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
5176
5177
5178
5179
5180
5181
5182
5183
5184
5185
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
5245
5246
5247
5248
5249
5250
5251
5252
5253
5254
5255
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
5315
5316
5317
5318
5319
5320
5321
5322
5323
5324
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
5384
5385
5386
5387
5388
5389
5390
5391
5392
5393
5394
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
5454
5455
5456
5457
5458
5459
5460
5461
5462
5463
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
5523
5524
5525
5526
5527
5528
5529
5530
5531
5532
5533
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
5593
5594
5595
5596
5597
5598
5599
5600
5601
5602
5603
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
5663
5664
5665
5666
5667
5668
5669
5670
5671
5672
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
5732
5733
5734
5735
5736
5737
5738
5739
5740
5741
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
5801
5802
5803
5804
5805
5806
5807
5808
5809
5810
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
5870
5871
5872
5873
5874
5875
5876
5877
5878
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
5938
5939
5940
5941
5942
5943
5944
5945
5946
5947
5948
5949
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
6009
6010
6011
6012
6013
6014
6015
6016
6017
6018
6019
6020
6021
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
6080
6081 }