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