|
1
6 package com.sun.corba.se.impl.logging ;
7
8 import java.util.logging.Logger  ;
9 import java.util.logging.Level ;
10
11 import org.omg.CORBA.OMGVMCID ;
12 import com.sun.corba.se.impl.util.SUNVMCID ;
13 import org.omg.CORBA.CompletionStatus ;
14 import org.omg.CORBA.SystemException ;
15
16 import com.sun.corba.se.spi.orb.ORB ;
17
18 import com.sun.corba.se.spi.logging.LogWrapperFactory;
19
20 import com.sun.corba.se.spi.logging.LogWrapperBase;
21
22 import org.omg.CORBA.BAD_CONTEXT ;
23 import org.omg.CORBA.BAD_INV_ORDER ;
24 import org.omg.CORBA.BAD_OPERATION ;
25 import org.omg.CORBA.BAD_PARAM ;
26 import org.omg.CORBA.BAD_TYPECODE ;
27 import org.omg.CORBA.DATA_CONVERSION ;
28 import org.omg.CORBA.IMP_LIMIT ;
29 import org.omg.CORBA.INITIALIZE ;
30 import org.omg.CORBA.INV_OBJREF ;
31 import org.omg.CORBA.INV_POLICY ;
32 import org.omg.CORBA.INTERNAL ;
33 import org.omg.CORBA.INTF_REPOS ;
34 import org.omg.CORBA.MARSHAL ;
35 import org.omg.CORBA.NO_IMPLEMENT ;
36 import org.omg.CORBA.NO_RESOURCES ;
37 import org.omg.CORBA.TRANSACTION_ROLLEDBACK ;
38 import org.omg.CORBA.TRANSIENT ;
39 import org.omg.CORBA.OBJECT_NOT_EXIST ;
40 import org.omg.CORBA.OBJ_ADAPTER ;
41 import org.omg.CORBA.UNKNOWN ;
42
43 public class OMGSystemException extends LogWrapperBase {
44
45 public OMGSystemException( Logger logger )
46 {
47 super( logger ) ;
48 }
49
50 private static LogWrapperFactory factory = new LogWrapperFactory() {
51 public LogWrapperBase create( Logger logger )
52 {
53 return new OMGSystemException( logger ) ;
54 }
55 } ;
56
57 public static OMGSystemException get( ORB orb, String logDomain )
58 {
59 OMGSystemException wrapper =
60 (OMGSystemException) orb.getLogWrapper( logDomain,
61 "OMG", factory ) ;
62 return wrapper ;
63 }
64
65 public static OMGSystemException get( String logDomain )
66 {
67 OMGSystemException wrapper =
68 (OMGSystemException) ORB.staticGetLogWrapper( logDomain,
69 "OMG", factory ) ;
70 return wrapper ;
71 }
72
73
77 public static final int IDL_CONTEXT_NOT_FOUND = OMGVMCID.value + 1 ;
78
79 public BAD_CONTEXT idlContextNotFound( CompletionStatus cs, Throwable t ) {
80 BAD_CONTEXT exc = new BAD_CONTEXT ( IDL_CONTEXT_NOT_FOUND, cs ) ;
81 if (t != null)
82 exc.initCause( t ) ;
83
84 if (logger.isLoggable( Level.WARNING )) {
85 Object [] parameters = null ;
86 doLog( Level.WARNING, "OMG.idlContextNotFound",
87 parameters, OMGSystemException.class, exc ) ;
88 }
89
90 return exc ;
91 }
92
93 public BAD_CONTEXT idlContextNotFound( CompletionStatus cs ) {
94 return idlContextNotFound( cs, null ) ;
95 }
96
97 public BAD_CONTEXT idlContextNotFound( Throwable t ) {
98 return idlContextNotFound( CompletionStatus.COMPLETED_NO, t ) ;
99 }
100
101 public BAD_CONTEXT idlContextNotFound( ) {
102 return idlContextNotFound( CompletionStatus.COMPLETED_NO, null ) ;
103 }
104
105 public static final int NO_MATCHING_IDL_CONTEXT = OMGVMCID.value + 2 ;
106
107 public BAD_CONTEXT noMatchingIdlContext( CompletionStatus cs, Throwable t ) {
108 BAD_CONTEXT exc = new BAD_CONTEXT ( NO_MATCHING_IDL_CONTEXT, cs ) ;
109 if (t != null)
110 exc.initCause( t ) ;
111
112 if (logger.isLoggable( Level.WARNING )) {
113 Object [] parameters = null ;
114 doLog( Level.WARNING, "OMG.noMatchingIdlContext",
115 parameters, OMGSystemException.class, exc ) ;
116 }
117
118 return exc ;
119 }
120
121 public BAD_CONTEXT noMatchingIdlContext( CompletionStatus cs ) {
122 return noMatchingIdlContext( cs, null ) ;
123 }
124
125 public BAD_CONTEXT noMatchingIdlContext( Throwable t ) {
126 return noMatchingIdlContext( CompletionStatus.COMPLETED_NO, t ) ;
127 }
128
129 public BAD_CONTEXT noMatchingIdlContext( ) {
130 return noMatchingIdlContext( CompletionStatus.COMPLETED_NO, null ) ;
131 }
132
133
137 public static final int DEP_PREVENT_DESTRUCTION = OMGVMCID.value + 1 ;
138
139 public BAD_INV_ORDER depPreventDestruction( CompletionStatus cs, Throwable t ) {
140 BAD_INV_ORDER exc = new BAD_INV_ORDER ( DEP_PREVENT_DESTRUCTION, cs ) ;
141 if (t != null)
142 exc.initCause( t ) ;
143
144 if (logger.isLoggable( Level.WARNING )) {
145 Object [] parameters = null ;
146 doLog( Level.WARNING, "OMG.depPreventDestruction",
147 parameters, OMGSystemException.class, exc ) ;
148 }
149
150 return exc ;
151 }
152
153 public BAD_INV_ORDER depPreventDestruction( CompletionStatus cs ) {
154 return depPreventDestruction( cs, null ) ;
155 }
156
157 public BAD_INV_ORDER depPreventDestruction( Throwable t ) {
158 return depPreventDestruction( CompletionStatus.COMPLETED_NO, t ) ;
159 }
160
161 public BAD_INV_ORDER depPreventDestruction( ) {
162 return depPreventDestruction( CompletionStatus.COMPLETED_NO, null ) ;
163 }
164
165 public static final int DESTROY_INDESTRUCTIBLE = OMGVMCID.value + 2 ;
166
167 public BAD_INV_ORDER destroyIndestructible( CompletionStatus cs, Throwable t ) {
168 BAD_INV_ORDER exc = new BAD_INV_ORDER ( DESTROY_INDESTRUCTIBLE, cs ) ;
169 if (t != null)
170 exc.initCause( t ) ;
171
172 if (logger.isLoggable( Level.WARNING )) {
173 Object [] parameters = null ;
174 doLog( Level.WARNING, "OMG.destroyIndestructible",
175 parameters, OMGSystemException.class, exc ) ;
176 }
177
178 return exc ;
179 }
180
181 public BAD_INV_ORDER destroyIndestructible( CompletionStatus cs ) {
182 return destroyIndestructible( cs, null ) ;
183 }
184
185 public BAD_INV_ORDER destroyIndestructible( Throwable t ) {
186 return destroyIndestructible( CompletionStatus.COMPLETED_NO, t ) ;
187 }
188
189 public BAD_INV_ORDER destroyIndestructible( ) {
190 return destroyIndestructible( CompletionStatus.COMPLETED_NO, null ) ;
191 }
192
193 public static final int SHUTDOWN_WAIT_FOR_COMPLETION_DEADLOCK = OMGVMCID.value + 3 ;
194
195 public BAD_INV_ORDER shutdownWaitForCompletionDeadlock( CompletionStatus cs, Throwable t ) {
196 BAD_INV_ORDER exc = new BAD_INV_ORDER ( SHUTDOWN_WAIT_FOR_COMPLETION_DEADLOCK, cs ) ;
197 if (t != null)
198 exc.initCause( t ) ;
199
200 if (logger.isLoggable( Level.WARNING )) {
201 Object [] parameters = null ;
202 doLog( Level.WARNING, "OMG.shutdownWaitForCompletionDeadlock",
203 parameters, OMGSystemException.class, exc ) ;
204 }
205
206 return exc ;
207 }
208
209 public BAD_INV_ORDER shutdownWaitForCompletionDeadlock( CompletionStatus cs ) {
210 return shutdownWaitForCompletionDeadlock( cs, null ) ;
211 }
212
213 public BAD_INV_ORDER shutdownWaitForCompletionDeadlock( Throwable t ) {
214 return shutdownWaitForCompletionDeadlock( CompletionStatus.COMPLETED_NO, t ) ;
215 }
216
217 public BAD_INV_ORDER shutdownWaitForCompletionDeadlock( ) {
218 return shutdownWaitForCompletionDeadlock( CompletionStatus.COMPLETED_NO, null ) ;
219 }
220
221 public static final int BAD_OPERATION_AFTER_SHUTDOWN = OMGVMCID.value + 4 ;
222
223 public BAD_INV_ORDER badOperationAfterShutdown( CompletionStatus cs, Throwable t ) {
224 BAD_INV_ORDER exc = new BAD_INV_ORDER ( BAD_OPERATION_AFTER_SHUTDOWN, cs ) ;
225 if (t != null)
226 exc.initCause( t ) ;
227
228 if (logger.isLoggable( Level.WARNING )) {
229 Object [] parameters = null ;
230 doLog( Level.WARNING, "OMG.badOperationAfterShutdown",
231 parameters, OMGSystemException.class, exc ) ;
232 }
233
234 return exc ;
235 }
236
237 public BAD_INV_ORDER badOperationAfterShutdown( CompletionStatus cs ) {
238 return badOperationAfterShutdown( cs, null ) ;
239 }
240
241 public BAD_INV_ORDER badOperationAfterShutdown( Throwable t ) {
242 return badOperationAfterShutdown( CompletionStatus.COMPLETED_NO, t ) ;
243 }
244
245 public BAD_INV_ORDER badOperationAfterShutdown( ) {
246 return badOperationAfterShutdown( CompletionStatus.COMPLETED_NO, null ) ;
247 }
248
249 public static final int BAD_INVOKE = OMGVMCID.value + 5 ;
250
251 public BAD_INV_ORDER badInvoke( CompletionStatus cs, Throwable t ) {
252 BAD_INV_ORDER exc = new BAD_INV_ORDER ( BAD_INVOKE, cs ) ;
253 if (t != null)
254 exc.initCause( t ) ;
255
256 if (logger.isLoggable( Level.WARNING )) {
257 Object [] parameters = null ;
258 doLog( Level.WARNING, "OMG.badInvoke",
259 parameters, OMGSystemException.class, exc ) ;
260 }
261
262 return exc ;
263 }
264
265 public BAD_INV_ORDER badInvoke( CompletionStatus cs ) {
266 return badInvoke( cs, null ) ;
267 }
268
269 public BAD_INV_ORDER badInvoke( Throwable t ) {
270 return badInvoke( CompletionStatus.COMPLETED_NO, t ) ;
271 }
272
273 public BAD_INV_ORDER badInvoke( ) {
274 return badInvoke( CompletionStatus.COMPLETED_NO, null ) ;
275 }
276
277 public static final int BAD_SET_SERVANT_MANAGER = OMGVMCID.value + 6 ;
278
279 public BAD_INV_ORDER badSetServantManager( CompletionStatus cs, Throwable t ) {
280 BAD_INV_ORDER exc = new BAD_INV_ORDER ( BAD_SET_SERVANT_MANAGER, cs ) ;
281 if (t != null)
282 exc.initCause( t ) ;
283
284 if (logger.isLoggable( Level.WARNING )) {
285 Object [] parameters = null ;
286 doLog( Level.WARNING, "OMG.badSetServantManager",
287 parameters, OMGSystemException.class, exc ) ;
288 }
289
290 return exc ;
291 }
292
293 public BAD_INV_ORDER badSetServantManager( CompletionStatus cs ) {
294 return badSetServantManager( cs, null ) ;
295 }
296
297 public BAD_INV_ORDER badSetServantManager( Throwable t ) {
298 return badSetServantManager( CompletionStatus.COMPLETED_NO, t ) ;
299 }
300
301 public BAD_INV_ORDER badSetServantManager( ) {
302 return badSetServantManager( CompletionStatus.COMPLETED_NO, null ) ;
303 }
304
305 public static final int BAD_ARGUMENTS_CALL = OMGVMCID.value + 7 ;
306
307 public BAD_INV_ORDER badArgumentsCall( CompletionStatus cs, Throwable t ) {
308 BAD_INV_ORDER exc = new BAD_INV_ORDER ( BAD_ARGUMENTS_CALL, cs ) ;
309 if (t != null)
310 exc.initCause( t ) ;
311
312 if (logger.isLoggable( Level.WARNING )) {
313 Object [] parameters = null ;
314 doLog( Level.WARNING, "OMG.badArgumentsCall",
315 parameters, OMGSystemException.class, exc ) ;
316 }
317
318 return exc ;
319 }
320
321 public BAD_INV_ORDER badArgumentsCall( CompletionStatus cs ) {
322 return badArgumentsCall( cs, null ) ;
323 }
324
325 public BAD_INV_ORDER badArgumentsCall( Throwable t ) {
326 return badArgumentsCall( CompletionStatus.COMPLETED_NO, t ) ;
327 }
328
329 public BAD_INV_ORDER badArgumentsCall( ) {
330 return badArgumentsCall( CompletionStatus.COMPLETED_NO, null ) ;
331 }
332
333 public static final int BAD_CTX_CALL = OMGVMCID.value + 8 ;
334
335 public BAD_INV_ORDER badCtxCall( CompletionStatus cs, Throwable t ) {
336 BAD_INV_ORDER exc = new BAD_INV_ORDER ( BAD_CTX_CALL, cs ) ;
337 if (t != null)
338 exc.initCause( t ) ;
339
340 if (logger.isLoggable( Level.WARNING )) {
341 Object [] parameters = null ;
342 doLog( Level.WARNING, "OMG.badCtxCall",
343 parameters, OMGSystemException.class, exc ) ;
344 }
345
346 return exc ;
347 }
348
349 public BAD_INV_ORDER badCtxCall( CompletionStatus cs ) {
350 return badCtxCall( cs, null ) ;
351 }
352
353 public BAD_INV_ORDER badCtxCall( Throwable t ) {
354 return badCtxCall( CompletionStatus.COMPLETED_NO, t ) ;
355 }
356
357 public BAD_INV_ORDER badCtxCall( ) {
358 return badCtxCall( CompletionStatus.COMPLETED_NO, null ) ;
359 }
360
361 public static final int BAD_RESULT_CALL = OMGVMCID.value + 9 ;
362
363 public BAD_INV_ORDER badResultCall( CompletionStatus cs, Throwable t ) {
364 BAD_INV_ORDER exc = new BAD_INV_ORDER ( BAD_RESULT_CALL, cs ) ;
365 if (t != null)
366 exc.initCause( t ) ;
367
368 if (logger.isLoggable( Level.WARNING )) {
369 Object [] parameters = null ;
370 doLog( Level.WARNING, "OMG.badResultCall",
371 parameters, OMGSystemException.class, exc ) ;
372 }
373
374 return exc ;
375 }
376
377 public BAD_INV_ORDER badResultCall( CompletionStatus cs ) {
378 return badResultCall( cs, null ) ;
379 }
380
381 public BAD_INV_ORDER badResultCall( Throwable t ) {
382 return badResultCall( CompletionStatus.COMPLETED_NO, t ) ;
383 }
384
385 public BAD_INV_ORDER badResultCall( ) {
386 return badResultCall( CompletionStatus.COMPLETED_NO, null ) ;
387 }
388
389 public static final int BAD_SEND = OMGVMCID.value + 10 ;
390
391 public BAD_INV_ORDER badSend( CompletionStatus cs, Throwable t ) {
392 BAD_INV_ORDER exc = new BAD_INV_ORDER ( BAD_SEND, cs ) ;
393 if (t != null)
394 exc.initCause( t ) ;
395
396 if (logger.isLoggable( Level.WARNING )) {
397 Object [] parameters = null ;
398 doLog( Level.WARNING, "OMG.badSend",
399 parameters, OMGSystemException.class, exc ) ;
400 }
401
402 return exc ;
403 }
404
405 public BAD_INV_ORDER badSend( CompletionStatus cs ) {
406 return badSend( cs, null ) ;
407 }
408
409 public BAD_INV_ORDER badSend( Throwable t ) {
410 return badSend( CompletionStatus.COMPLETED_NO, t ) ;
411 }
412
413 public BAD_INV_ORDER badSend( ) {
414 return badSend( CompletionStatus.COMPLETED_NO, null ) ;
415 }
416
417 public static final int BAD_POLL_BEFORE = OMGVMCID.value + 11 ;
418
419 public BAD_INV_ORDER badPollBefore( CompletionStatus cs, Throwable t ) {
420 BAD_INV_ORDER exc = new BAD_INV_ORDER ( BAD_POLL_BEFORE, cs ) ;
421 if (t != null)
422 exc.initCause( t ) ;
423
424 if (logger.isLoggable( Level.WARNING )) {
425 Object [] parameters = null ;
426 doLog( Level.WARNING, "OMG.badPollBefore",
427 parameters, OMGSystemException.class, exc ) ;
428 }
429
430 return exc ;
431 }
432
433 public BAD_INV_ORDER badPollBefore( CompletionStatus cs ) {
434 return badPollBefore( cs, null ) ;
435 }
436
437 public BAD_INV_ORDER badPollBefore( Throwable t ) {
438 return badPollBefore( CompletionStatus.COMPLETED_NO, t ) ;
439 }
440
441 public BAD_INV_ORDER badPollBefore( ) {
442 return badPollBefore( CompletionStatus.COMPLETED_NO, null ) ;
443 }
444
445 public static final int BAD_POLL_AFTER = OMGVMCID.value + 12 ;
446
447 public BAD_INV_ORDER badPollAfter( CompletionStatus cs, Throwable t ) {
448 BAD_INV_ORDER exc = new BAD_INV_ORDER ( BAD_POLL_AFTER, cs ) ;
449 if (t != null)
450 exc.initCause( t ) ;
451
452 if (logger.isLoggable( Level.WARNING )) {
453 Object [] parameters = null ;
454 doLog( Level.WARNING, "OMG.badPollAfter",
455 parameters, OMGSystemException.class, exc ) ;
456 }
457
458 return exc ;
459 }
460
461 public BAD_INV_ORDER badPollAfter( CompletionStatus cs ) {
462 return badPollAfter( cs, null ) ;
463 }
464
465 public BAD_INV_ORDER badPollAfter( Throwable t ) {
466 return badPollAfter( CompletionStatus.COMPLETED_NO, t ) ;
467 }
468
469 public BAD_INV_ORDER badPollAfter( ) {
470 return badPollAfter( CompletionStatus.COMPLETED_NO, null ) ;
471 }
472
473 public static final int BAD_POLL_SYNC = OMGVMCID.value + 13 ;
474
475 public BAD_INV_ORDER badPollSync( CompletionStatus cs, Throwable t ) {
476 BAD_INV_ORDER exc = new BAD_INV_ORDER ( BAD_POLL_SYNC, cs ) ;
477 if (t != null)
478 exc.initCause( t ) ;
479
480 if (logger.isLoggable( Level.WARNING )) {
481 Object [] parameters = null ;
482 doLog( Level.WARNING, "OMG.badPollSync",
483 parameters, OMGSystemException.class, exc ) ;
484 }
485
486 return exc ;
487 }
488
489 public BAD_INV_ORDER badPollSync( CompletionStatus cs ) {
490 return badPollSync( cs, null ) ;
491 }
492
493 public BAD_INV_ORDER badPollSync( Throwable t ) {
494 return badPollSync( CompletionStatus.COMPLETED_NO, t ) ;
495 }
496
497 public BAD_INV_ORDER badPollSync( ) {
498 return badPollSync( CompletionStatus.COMPLETED_NO, null ) ;
499 }
500
501 public static final int INVALID_PI_CALL1 = OMGVMCID.value + 14 ;
502
503 public BAD_INV_ORDER invalidPiCall1( CompletionStatus cs, Throwable t ) {
504 BAD_INV_ORDER exc = new BAD_INV_ORDER ( INVALID_PI_CALL1, cs ) ;
505 if (t != null)
506 exc.initCause( t ) ;
507
508 if (logger.isLoggable( Level.FINE )) {
509 Object [] parameters = null ;
510 doLog( Level.FINE, "OMG.invalidPiCall1",
511 parameters, OMGSystemException.class, exc ) ;
512 }
513
514 return exc ;
515 }
516
517 public BAD_INV_ORDER invalidPiCall1( CompletionStatus cs ) {
518 return invalidPiCall1( cs, null ) ;
519 }
520
521 public BAD_INV_ORDER invalidPiCall1( Throwable t ) {
522 return invalidPiCall1( CompletionStatus.COMPLETED_NO, t ) ;
523 }
524
525 public BAD_INV_ORDER invalidPiCall1( ) {
526 return invalidPiCall1( CompletionStatus.COMPLETED_NO, null ) ;
527 }
528
529 public static final int INVALID_PI_CALL2 = OMGVMCID.value + 14 ;
530
531 public BAD_INV_ORDER invalidPiCall2( CompletionStatus cs, Throwable t ) {
532 BAD_INV_ORDER exc = new BAD_INV_ORDER ( INVALID_PI_CALL2, cs ) ;
533 if (t != null)
534 exc.initCause( t ) ;
535
536 if (logger.isLoggable( Level.FINE )) {
537 Object [] parameters = null ;
538 doLog( Level.FINE, "OMG.invalidPiCall2",
539 parameters, OMGSystemException.class, exc ) ;
540 }
541
542 return exc ;
543 }
544
545 public BAD_INV_ORDER invalidPiCall2( CompletionStatus cs ) {
546 return invalidPiCall2( cs, null ) ;
547 }
548
549 public BAD_INV_ORDER invalidPiCall2( Throwable t ) {
550 return invalidPiCall2( CompletionStatus.COMPLETED_NO, t ) ;
551 }
552
553 public BAD_INV_ORDER invalidPiCall2( ) {
554 return invalidPiCall2( CompletionStatus.COMPLETED_NO, null ) ;
555 }
556
557 public static final int INVALID_PI_CALL3 = OMGVMCID.value + 14 ;
558
559 public BAD_INV_ORDER invalidPiCall3( CompletionStatus cs, Throwable t ) {
560 BAD_INV_ORDER exc = new BAD_INV_ORDER ( INVALID_PI_CALL3, cs ) ;
561 if (t != null)
562 exc.initCause( t ) ;
563
564 if (logger.isLoggable( Level.FINE )) {
565 Object [] parameters = null ;
566 doLog( Level.FINE, "OMG.invalidPiCall3",
567 parameters, OMGSystemException.class, exc ) ;
568 }
569
570 return exc ;
571 }
572
573 public BAD_INV_ORDER invalidPiCall3( CompletionStatus cs ) {
574 return invalidPiCall3( cs, null ) ;
575 }
576
577 public BAD_INV_ORDER invalidPiCall3( Throwable t ) {
578 return invalidPiCall3( CompletionStatus.COMPLETED_NO, t ) ;
579 }
580
581 public BAD_INV_ORDER invalidPiCall3( ) {
582 return invalidPiCall3( CompletionStatus.COMPLETED_NO, null ) ;
583 }
584
585 public static final int INVALID_PI_CALL4 = OMGVMCID.value + 14 ;
586
587 public BAD_INV_ORDER invalidPiCall4( CompletionStatus cs, Throwable t ) {
588 BAD_INV_ORDER exc = new BAD_INV_ORDER ( INVALID_PI_CALL4, cs ) ;
589 if (t != null)
590 exc.initCause( t ) ;
591
592 if (logger.isLoggable( Level.FINE )) {
593 Object [] parameters = null ;
594 doLog( Level.FINE, "OMG.invalidPiCall4",
595 parameters, OMGSystemException.class, exc ) ;
596 }
597
598 return exc ;
599 }
600
601 public BAD_INV_ORDER invalidPiCall4( CompletionStatus cs ) {
602 return invalidPiCall4( cs, null ) ;
603 }
604
605 public BAD_INV_ORDER invalidPiCall4( Throwable t ) {
606 return invalidPiCall4( CompletionStatus.COMPLETED_NO, t ) ;
607 }
608
609 public BAD_INV_ORDER invalidPiCall4( ) {
610 return invalidPiCall4( CompletionStatus.COMPLETED_NO, null ) ;
611 }
612
613 public static final int SERVICE_CONTEXT_ADD_FAILED = OMGVMCID.value + 15 ;
614
615 public BAD_INV_ORDER serviceContextAddFailed( CompletionStatus cs, Throwable t, Object arg0) {
616 BAD_INV_ORDER exc = new BAD_INV_ORDER ( SERVICE_CONTEXT_ADD_FAILED, cs ) ;
617 if (t != null)
618 exc.initCause( t ) ;
619
620 if (logger.isLoggable( Level.FINE )) {
621 Object [] parameters = new Object [1] ;
622 parameters[0] = arg0 ;
623 doLog( Level.FINE, "OMG.serviceContextAddFailed",
624 parameters, OMGSystemException.class, exc ) ;
625 }
626
627 return exc ;
628 }
629
630 public BAD_INV_ORDER serviceContextAddFailed( CompletionStatus cs, Object arg0) {
631 return serviceContextAddFailed( cs, null, arg0 ) ;
632 }
633
634 public BAD_INV_ORDER serviceContextAddFailed( Throwable t, Object arg0) {
635 return serviceContextAddFailed( CompletionStatus.COMPLETED_NO, t, arg0 ) ;
636 }
637
638 public BAD_INV_ORDER serviceContextAddFailed( Object arg0) {
639 return serviceContextAddFailed( CompletionStatus.COMPLETED_NO, null, arg0 ) ;
640 }
641
642 public static final int POLICY_FACTORY_REG_FAILED = OMGVMCID.value + 16 ;
643
644 public BAD_INV_ORDER policyFactoryRegFailed( CompletionStatus cs, Throwable t, Object arg0) {
645 BAD_INV_ORDER exc = new BAD_INV_ORDER ( POLICY_FACTORY_REG_FAILED, cs ) ;
646 if (t != null)
647 exc.initCause( t ) ;
648
649 if (logger.isLoggable( Level.WARNING )) {
650 Object [] parameters = new Object [1] ;
651 parameters[0] = arg0 ;
652 doLog( Level.WARNING, "OMG.policyFactoryRegFailed",
653 parameters, OMGSystemException.class, exc ) ;
654 }
655
656 return exc ;
657 }
658
659 public BAD_INV_ORDER policyFactoryRegFailed( CompletionStatus cs, Object arg0) {
660 return policyFactoryRegFailed( cs, null, arg0 ) ;
661 }
662
663 public BAD_INV_ORDER policyFactoryRegFailed( Throwable t, Object arg0) {
664 return policyFactoryRegFailed( CompletionStatus.COMPLETED_NO, t, arg0 ) ;
665 }
666
667 public BAD_INV_ORDER policyFactoryRegFailed( Object arg0) {
668 return policyFactoryRegFailed( CompletionStatus.COMPLETED_NO, null, arg0 ) ;
669 }
670
671 public static final int CREATE_POA_DESTROY = OMGVMCID.value + 17 ;
672
673 public BAD_INV_ORDER createPoaDestroy( CompletionStatus cs, Throwable t ) {
674 BAD_INV_ORDER exc = new BAD_INV_ORDER ( CREATE_POA_DESTROY, cs ) ;
675 if (t != null)
676 exc.initCause( t ) ;
677
678 if (logger.isLoggable( Level.WARNING )) {
679 Object [] parameters = null ;
680 doLog( Level.WARNING, "OMG.createPoaDestroy",
681 parameters, OMGSystemException.class, exc ) ;
682 }
683
684 return exc ;
685 }
686
687 public BAD_INV_ORDER createPoaDestroy( CompletionStatus cs ) {
688 return createPoaDestroy( cs, null ) ;
689 }
690
691 public BAD_INV_ORDER createPoaDestroy( Throwable t ) {
692 return createPoaDestroy( CompletionStatus.COMPLETED_NO, t ) ;
693 }
694
695 public BAD_INV_ORDER createPoaDestroy( ) {
696 return createPoaDestroy( CompletionStatus.COMPLETED_NO, null ) ;
697 }
698
699 public static final int PRIORITY_REASSIGN = OMGVMCID.value + 18 ;
700
701 public BAD_INV_ORDER priorityReassign( CompletionStatus cs, Throwable t ) {
702 BAD_INV_ORDER exc = new BAD_INV_ORDER ( PRIORITY_REASSIGN, cs ) ;
703 if (t != null)
704 exc.initCause( t ) ;
705
706 if (logger.isLoggable( Level.WARNING )) {
707 Object [] parameters = null ;
708 doLog( Level.WARNING, "OMG.priorityReassign",
709 parameters, OMGSystemException.class, exc ) ;
710 }
711
712 return exc ;
713 }
714
715 public BAD_INV_ORDER priorityReassign( CompletionStatus cs ) {
716 return priorityReassign( cs, null ) ;
717 }
718
719 public BAD_INV_ORDER priorityReassign( Throwable t ) {
720 return priorityReassign( CompletionStatus.COMPLETED_NO, t ) ;
721 }
722
723 public BAD_INV_ORDER priorityReassign( ) {
724 return priorityReassign( CompletionStatus.COMPLETED_NO, null ) ;
725 }
726
727 public static final int XA_START_OUTSIZE = OMGVMCID.value + 19 ;
728
729 public BAD_INV_ORDER xaStartOutsize( CompletionStatus cs, Throwable t ) {
730 BAD_INV_ORDER exc = new BAD_INV_ORDER ( XA_START_OUTSIZE, cs ) ;
731 if (t != null)
732 exc.initCause( t ) ;
733
734 if (logger.isLoggable( Level.WARNING )) {
735 Object [] parameters = null ;
736 doLog( Level.WARNING, "OMG.xaStartOutsize",
737 parameters, OMGSystemException.class, exc ) ;
738 }
739
740 return exc ;
741 }
742
743 public BAD_INV_ORDER xaStartOutsize( CompletionStatus cs ) {
744 return xaStartOutsize( cs, null ) ;
745 }
746
747 public BAD_INV_ORDER xaStartOutsize( Throwable t ) {
748 return xaStartOutsize( CompletionStatus.COMPLETED_NO, t ) ;
749 }
750
751 public BAD_INV_ORDER xaStartOutsize( ) {
752 return xaStartOutsize( CompletionStatus.COMPLETED_NO, null ) ;
753 }
754
755 public static final int XA_START_PROTO = OMGVMCID.value + 20 ;
756
757 public BAD_INV_ORDER xaStartProto( CompletionStatus cs, Throwable t ) {
758 BAD_INV_ORDER exc = new BAD_INV_ORDER ( XA_START_PROTO, cs ) ;
759 if (t != null)
760 exc.initCause( t ) ;
761
762 if (logger.isLoggable( Level.WARNING )) {
763 Object [] parameters = null ;
764 doLog( Level.WARNING, "OMG.xaStartProto",
765 parameters, OMGSystemException.class, exc ) ;
766 }
767
768 return exc ;
769 }
770
771 public BAD_INV_ORDER xaStartProto( CompletionStatus cs ) {
772 return xaStartProto( cs, null ) ;
773 }
774
775 public BAD_INV_ORDER xaStartProto( Throwable t ) {
776 return xaStartProto( CompletionStatus.COMPLETED_NO, t ) ;
777 }
778
779 public BAD_INV_ORDER xaStartProto( ) {
780 return xaStartProto( CompletionStatus.COMPLETED_NO, null ) ;
781 }
782
783
787 public static final int BAD_SERVANT_MANAGER_TYPE = OMGVMCID.value + 1 ;
788
789 public BAD_OPERATION badServantManagerType( CompletionStatus cs, Throwable t ) {
790 BAD_OPERATION exc = new BAD_OPERATION ( BAD_SERVANT_MANAGER_TYPE, cs ) ;
791 if (t != null)
792 exc.initCause( t ) ;
793
794 if (logger.isLoggable( Level.WARNING )) {
795 Object [] parameters = null ;
796 doLog( Level.WARNING, "OMG.badServantManagerType",
797 parameters, OMGSystemException.class, exc ) ;
798 }
799
800 return exc ;
801 }
802
803 public BAD_OPERATION badServantManagerType( CompletionStatus cs ) {
804 return badServantManagerType( cs, null ) ;
805 }
806
807 public BAD_OPERATION badServantManagerType( Throwable t ) {
808 return badServantManagerType( CompletionStatus.COMPLETED_NO, t ) ;
809 }
810
811 public BAD_OPERATION badServantManagerType( ) {
812 return badServantManagerType( CompletionStatus.COMPLETED_NO, null ) ;
813 }
814
815 public static final int OPERATION_UNKNOWN_TO_TARGET = OMGVMCID.value + 2 ;
816
817 public BAD_OPERATION operationUnknownToTarget( CompletionStatus cs, Throwable t ) {
818 BAD_OPERATION exc = new BAD_OPERATION ( OPERATION_UNKNOWN_TO_TARGET, cs ) ;
819 if (t != null)
820 exc.initCause( t ) ;
821
822 if (logger.isLoggable( Level.WARNING )) {
823 Object [] parameters = null ;
824 doLog( Level.WARNING, "OMG.operationUnknownToTarget",
825 parameters, OMGSystemException.class, exc ) ;
826 }
827
828 return exc ;
829 }
830
831 public BAD_OPERATION operationUnknownToTarget( CompletionStatus cs ) {
832 return operationUnknownToTarget( cs, null ) ;
833 }
834
835 public BAD_OPERATION operationUnknownToTarget( Throwable t ) {
836 return operationUnknownToTarget( CompletionStatus.COMPLETED_NO, t ) ;
837 }
838
839 public BAD_OPERATION operationUnknownToTarget( ) {
840 return operationUnknownToTarget( CompletionStatus.COMPLETED_NO, null ) ;
841 }
842
843
847 public static final int UNABLE_REGISTER_VALUE_FACTORY = OMGVMCID.value + 1 ;
848
849 public BAD_PARAM unableRegisterValueFactory( CompletionStatus cs, Throwable t ) {
850 BAD_PARAM exc = new BAD_PARAM ( UNABLE_REGISTER_VALUE_FACTORY, cs ) ;
851 if (t != null)
852 exc.initCause( t ) ;
853
854 if (logger.isLoggable( Level.WARNING )) {
855 Object [] parameters = null ;
856 doLog( Level.WARNING, "OMG.unableRegisterValueFactory",
857 parameters, OMGSystemException.class, exc ) ;
858 }
859
860 return exc ;
861 }
862
863 public BAD_PARAM unableRegisterValueFactory( CompletionStatus cs ) {
864 return unableRegisterValueFactory( cs, null ) ;
865 }
866
867 public BAD_PARAM unableRegisterValueFactory( Throwable t ) {
868 return unableRegisterValueFactory( CompletionStatus.COMPLETED_NO, t ) ;
869 }
870
871 public BAD_PARAM unableRegisterValueFactory( ) {
872 return unableRegisterValueFactory( CompletionStatus.COMPLETED_NO, null ) ;
873 }
874
875 public static final int RID_ALREADY_DEFINED = OMGVMCID.value + 2 ;
876
877 public BAD_PARAM ridAlreadyDefined( CompletionStatus cs, Throwable t ) {
878 BAD_PARAM exc = new BAD_PARAM ( RID_ALREADY_DEFINED, cs ) ;
879 if (t != null)
880 exc.initCause( t ) ;
881
882 if (logger.isLoggable( Level.WARNING )) {
883 Object [] parameters = null ;
884 doLog( Level.WARNING, "OMG.ridAlreadyDefined",
885 parameters, OMGSystemException.class, exc ) ;
886 }
887
888 return exc ;
889 }
890
891 public BAD_PARAM ridAlreadyDefined( CompletionStatus cs ) {
892 return ridAlreadyDefined( cs, null ) ;
893 }
894
895 public BAD_PARAM ridAlreadyDefined( Throwable t ) {
896 return ridAlreadyDefined( CompletionStatus.COMPLETED_NO, t ) ;
897 }
898
899 public BAD_PARAM ridAlreadyDefined( ) {
900 return ridAlreadyDefined( CompletionStatus.COMPLETED_NO, null ) ;
901 }
902
903 public static final int NAME_USED_IFR = OMGVMCID.value + 3 ;
904
905 public BAD_PARAM nameUsedIfr( CompletionStatus cs, Throwable t ) {
906 BAD_PARAM exc = new BAD_PARAM ( NAME_USED_IFR, cs ) ;
907 if (t != null)
908 exc.initCause( t ) ;
909
910 if (logger.isLoggable( Level.WARNING )) {
911 Object [] parameters = null ;
912 doLog( Level.WARNING, "OMG.nameUsedIfr",
913 parameters, OMGSystemException.class, exc ) ;
914 }
915
916 return exc ;
917 }
918
919 public BAD_PARAM nameUsedIfr( CompletionStatus cs ) {
920 return nameUsedIfr( cs, null ) ;
921 }
922
923 public BAD_PARAM nameUsedIfr( Throwable t ) {
924 return nameUsedIfr( CompletionStatus.COMPLETED_NO, t ) ;
925 }
926
927 public BAD_PARAM nameUsedIfr( ) {
928 return nameUsedIfr( CompletionStatus.COMPLETED_NO, null ) ;
929 }
930
931 public static final int TARGET_NOT_CONTAINER = OMGVMCID.value + 4 ;
932
933 public BAD_PARAM targetNotContainer( CompletionStatus cs, Throwable t ) {
934 BAD_PARAM exc = new BAD_PARAM ( TARGET_NOT_CONTAINER, cs ) ;
935 if (t != null)
936 exc.initCause( t ) ;
937
938 if (logger.isLoggable( Level.WARNING )) {
939 Object [] parameters = null ;
940 doLog( Level.WARNING, "OMG.targetNotContainer",
941 parameters, OMGSystemException.class, exc ) ;
942 }
943
944 return exc ;
945 }
946
947 public BAD_PARAM targetNotContainer( CompletionStatus cs ) {
948 return targetNotContainer( cs, null ) ;
949 }
950
951 public BAD_PARAM targetNotContainer( Throwable t ) {
952 return targetNotContainer( CompletionStatus.COMPLETED_NO, t ) ;
953 }
954
955 public BAD_PARAM targetNotContainer( ) {
956 return targetNotContainer( CompletionStatus.COMPLETED_NO, null ) ;
957 }
958
959 public static final int NAME_CLASH = OMGVMCID.value + 5 ;
960
961 public BAD_PARAM nameClash( CompletionStatus cs, Throwable t ) {
962 BAD_PARAM exc = new BAD_PARAM ( NAME_CLASH, cs ) ;
963 if (t != null)
964 exc.initCause( t ) ;
965
966 if (logger.isLoggable( Level.WARNING )) {
967 Object [] parameters = null ;
968 doLog( Level.WARNING, "OMG.nameClash",
969 parameters, OMGSystemException.class, exc ) ;
970 }
971
972 return exc ;
973 }
974
975 public BAD_PARAM nameClash( CompletionStatus cs ) {
976 return nameClash( cs, null ) ;
977 }
978
979 public BAD_PARAM nameClash( Throwable t ) {
980 return nameClash( CompletionStatus.COMPLETED_NO, t ) ;
981 }
982
983 public BAD_PARAM nameClash( ) {
984 return nameClash( CompletionStatus.COMPLETED_NO, null ) ;
985 }
986
987 public static final int NOT_SERIALIZABLE = OMGVMCID.value + 6 ;
988
989 public BAD_PARAM notSerializable( CompletionStatus cs, Throwable t, Object arg0) {
990 BAD_PARAM exc = new BAD_PARAM ( NOT_SERIALIZABLE, cs ) ;
991 if (t != null)
992 exc.initCause( t ) ;
993
994 if (logger.isLoggable( Level.WARNING )) {
995 Object [] parameters = new Object [1] ;
996 parameters[0] = arg0 ;
997 doLog( Level.WARNING, "OMG.notSerializable",
998 parameters, OMGSystemException.class, exc ) ;
999 }
1000
1001 return exc ;
1002 }
1003
1004 public BAD_PARAM notSerializable( CompletionStatus cs, Object arg0) {
1005 return notSerializable( cs, null, arg0 ) ;
1006 }
1007
1008 public BAD_PARAM notSerializable( Throwable t, Object arg0) {
1009 return notSerializable( CompletionStatus.COMPLETED_NO, t, arg0 ) ;
1010 }
1011
1012 public BAD_PARAM notSerializable( Object arg0) {
1013 return notSerializable( CompletionStatus.COMPLETED_NO, null, arg0 ) ;
1014 }
1015
1016 public static final int SO_BAD_SCHEME_NAME = OMGVMCID.value + 7 ;
1017
1018 public BAD_PARAM soBadSchemeName( CompletionStatus cs, Throwable t ) {
1019 BAD_PARAM exc = new BAD_PARAM ( SO_BAD_SCHEME_NAME, cs ) ;
1020 if (t != null)
1021 exc.initCause( t ) ;
1022
1023 if (logger.isLoggable( Level.WARNING )) {
1024 Object [] parameters = null ;
1025 doLog( Level.WARNING, "OMG.soBadSchemeName",
1026 parameters, OMGSystemException.class, exc ) ;
1027 }
1028
1029 return exc ;
1030 }
1031
1032 public BAD_PARAM soBadSchemeName( CompletionStatus cs ) {
1033 return soBadSchemeName( cs, null ) ;
1034 }
1035
1036 public BAD_PARAM soBadSchemeName( Throwable t ) {
1037 return soBadSchemeName( CompletionStatus.COMPLETED_NO, t ) ;
1038 }
1039
1040 public BAD_PARAM soBadSchemeName( ) {
1041 return soBadSchemeName( CompletionStatus.COMPLETED_NO, null ) ;
1042 }
1043
1044 public static final int SO_BAD_ADDRESS = OMGVMCID.value + 8 ;
1045
1046 public BAD_PARAM soBadAddress( CompletionStatus cs, Throwable t ) {
1047 BAD_PARAM exc = new BAD_PARAM ( SO_BAD_ADDRESS, cs ) ;
1048 if (t != null)
1049 exc.initCause( t ) ;
1050
1051 if (logger.isLoggable( Level.WARNING )) {
1052 Object [] parameters = null ;
1053 doLog( Level.WARNING, "OMG.soBadAddress",
1054 parameters, OMGSystemException.class, exc ) ;
1055 }
1056
1057 return exc ;
1058 }
1059
1060 public BAD_PARAM soBadAddress( CompletionStatus cs ) {
1061 return soBadAddress( cs, null ) ;
1062 }
1063
1064 public BAD_PARAM soBadAddress( Throwable t ) {
1065 return soBadAddress( CompletionStatus.COMPLETED_NO, t ) ;
1066 }
1067
1068 public BAD_PARAM soBadAddress( ) {
1069 return soBadAddress( CompletionStatus.COMPLETED_NO, null ) ;
1070 }
1071
1072 public static final int SO_BAD_SCHEMA_SPECIFIC = OMGVMCID.value + 9 ;
1073
1074 public BAD_PARAM soBadSchemaSpecific( CompletionStatus cs, Throwable t ) {
1075 BAD_PARAM exc = new BAD_PARAM ( SO_BAD_SCHEMA_SPECIFIC, cs ) ;
1076 if (t != null)
1077 exc.initCause( t ) ;
1078
1079 if (logger.isLoggable( Level.WARNING )) {
1080 Object [] parameters = null ;
1081 doLog( Level.WARNING, "OMG.soBadSchemaSpecific",
1082 parameters, OMGSystemException.class, exc ) ;
1083 }
1084
1085 return exc ;
1086 }
1087
1088 public BAD_PARAM soBadSchemaSpecific( CompletionStatus cs ) {
1089 return soBadSchemaSpecific( cs, null ) ;
1090 }
1091
1092 public BAD_PARAM soBadSchemaSpecific( Throwable t ) {
1093 return soBadSchemaSpecific( CompletionStatus.COMPLETED_NO, t ) ;
1094 }
1095
1096 public BAD_PARAM soBadSchemaSpecific( ) {
1097 return soBadSchemaSpecific( CompletionStatus.COMPLETED_NO, null ) ;
1098 }
1099
1100 public static final int SO_NON_SPECIFIC = OMGVMCID.value + 10 ;
1101
1102 public BAD_PARAM soNonSpecific( CompletionStatus cs, Throwable t ) {
1103 BAD_PARAM exc = new BAD_PARAM ( SO_NON_SPECIFIC, cs ) ;
1104 if (t != null)
1105 exc.initCause( t ) ;
1106
1107 if (logger.isLoggable( Level.WARNING )) {
1108 Object [] parameters = null ;
1109 doLog( Level.WARNING, "OMG.soNonSpecific",
1110 parameters, OMGSystemException.class, exc ) ;
1111 }
1112
1113 return exc ;
1114 }
1115
1116 public BAD_PARAM soNonSpecific( CompletionStatus cs ) {
1117 return soNonSpecific( cs, null ) ;
1118 }
1119
1120 public BAD_PARAM soNonSpecific( Throwable t ) {
1121 return soNonSpecific( CompletionStatus.COMPLETED_NO, t ) ;
1122 }
1123
1124 public BAD_PARAM soNonSpecific( ) {
1125 return soNonSpecific( CompletionStatus.COMPLETED_NO, null ) ;
1126 }
1127
1128 public static final int IR_DERIVE_ABS_INT_BASE = OMGVMCID.value + 11 ;
1129
1130 public BAD_PARAM irDeriveAbsIntBase( CompletionStatus cs, Throwable t ) {
1131 BAD_PARAM exc = new BAD_PARAM ( IR_DERIVE_ABS_INT_BASE, cs ) ;
1132 if (t != null)
1133 exc.initCause( t ) ;
1134
1135 if (logger.isLoggable( Level.WARNING )) {
1136 Object [] parameters = null ;
1137 doLog( Level.WARNING, "OMG.irDeriveAbsIntBase",
1138 parameters, OMGSystemException.class, exc ) ;
1139 }
1140
1141 return exc ;
1142 }
1143
1144 public BAD_PARAM irDeriveAbsIntBase( CompletionStatus cs ) {
1145 return irDeriveAbsIntBase( cs, null ) ;
1146 }
1147
1148 public BAD_PARAM irDeriveAbsIntBase( Throwable t ) {
1149 return irDeriveAbsIntBase( CompletionStatus.COMPLETED_NO, t ) ;
1150 }
1151
1152 public BAD_PARAM irDeriveAbsIntBase( ) {
1153 return irDeriveAbsIntBase( CompletionStatus.COMPLETED_NO, null ) ;
1154 }
1155
1156 public static final int IR_VALUE_SUPPORT = OMGVMCID.value + 12 ;
1157
1158 public BAD_PARAM irValueSupport( CompletionStatus cs, Throwable t ) {
1159 BAD_PARAM exc = new BAD_PARAM ( IR_VALUE_SUPPORT, cs ) ;
1160 if (t != null)
1161 exc.initCause( t ) ;
1162
1163 if (logger.isLoggable( Level.WARNING )) {
1164 Object [] parameters = null ;
1165 doLog( Level.WARNING, "OMG.irValueSupport",
1166 parameters, OMGSystemException.class, exc ) ;
1167 }
1168
1169 return exc ;
1170 }
1171
1172 public BAD_PARAM irValueSupport( CompletionStatus cs ) {
1173 return irValueSupport( cs, null ) ;
1174 }
1175
1176 public BAD_PARAM irValueSupport( Throwable t ) {
1177 return irValueSupport( CompletionStatus.COMPLETED_NO, t ) ;
1178 }
1179
1180 public BAD_PARAM irValueSupport( ) {
1181 return irValueSupport( CompletionStatus.COMPLETED_NO, null ) ;
1182 }
1183
1184 public static final int INCOMPLETE_TYPECODE = OMGVMCID.value + 13 ;
1185
1186 public BAD_PARAM incompleteTypecode( CompletionStatus cs, Throwable t ) {
1187 BAD_PARAM exc = new BAD_PARAM ( INCOMPLETE_TYPECODE, cs ) ;
1188 if (t != null)
1189 exc.initCause( t ) ;
1190
1191 if (logger.isLoggable( Level.WARNING )) {
1192 Object [] parameters = null ;
1193 doLog( Level.WARNING, "OMG.incompleteTypecode",
1194 parameters, OMGSystemException.class, exc ) ;
1195 }
1196
1197 return exc ;
1198 }
1199
1200 public BAD_PARAM incompleteTypecode( CompletionStatus cs ) {
1201 return incompleteTypecode( cs, null ) ;
1202 }
1203
1204 public BAD_PARAM incompleteTypecode( Throwable t ) {
1205 return incompleteTypecode( CompletionStatus.COMPLETED_NO, t ) ;
1206 }
1207
1208 public BAD_PARAM incompleteTypecode( ) {
1209 return incompleteTypecode( CompletionStatus.COMPLETED_NO, null ) ;
1210 }
1211
1212 public static final int INVALID_OBJECT_ID = OMGVMCID.value + 14 ;
1213
1214 public BAD_PARAM invalidObjectId( CompletionStatus cs, Throwable t ) {
1215 BAD_PARAM exc = new BAD_PARAM ( INVALID_OBJECT_ID, cs ) ;
1216 if (t != null)
1217 exc.initCause( t ) ;
1218
1219 if (logger.isLoggable( Level.WARNING )) {
1220 Object [] parameters = null ;
1221 doLog( Level.WARNING, "OMG.invalidObjectId",
1222 parameters, OMGSystemException.class, exc ) ;
1223 }
1224
1225 return exc ;
1226 }
1227
1228 public BAD_PARAM invalidObjectId( CompletionStatus cs ) {
1229 return invalidObjectId( cs, null ) ;
1230 }
1231
1232 public BAD_PARAM invalidObjectId( Throwable t ) {
1233 return invalidObjectId( CompletionStatus.COMPLETED_NO, t ) ;
1234 }
1235
1236 public BAD_PARAM invalidObjectId( ) {
1237 return invalidObjectId( CompletionStatus.COMPLETED_NO, null ) ;
1238 }
1239
1240 public static final int TYPECODE_BAD_NAME = OMGVMCID.value + 15 ;
1241
1242 public BAD_PARAM typecodeBadName( CompletionStatus cs, Throwable t ) {
1243 BAD_PARAM exc = new BAD_PARAM ( TYPECODE_BAD_NAME, cs ) ;
1244 if (t != null)
1245 exc.initCause( t ) ;
1246
1247 if (logger.isLoggable( Level.WARNING )) {
1248 Object [] parameters = null ;
1249 doLog( Level.WARNING, "OMG.typecodeBadName",
1250 parameters, OMGSystemException.class, exc ) ;
1251 }
1252
1253 return exc ;
1254 }
1255
1256 public BAD_PARAM typecodeBadName( CompletionStatus cs ) {
1257 return typecodeBadName( cs, null ) ;
1258 }
1259
1260 public BAD_PARAM typecodeBadName( Throwable t ) {
1261 return typecodeBadName( CompletionStatus.COMPLETED_NO, t ) ;
1262 }
1263
1264 public BAD_PARAM typecodeBadName( ) {
1265 return typecodeBadName( CompletionStatus.COMPLETED_NO, null ) ;
1266 }
1267
1268 public static final int TYPECODE_BAD_REPID = OMGVMCID.value + 16 ;
1269
1270 public BAD_PARAM typecodeBadRepid( CompletionStatus cs, Throwable t ) {
1271 BAD_PARAM exc = new BAD_PARAM ( TYPECODE_BAD_REPID, cs ) ;
1272 if (t != null)
1273 exc.initCause( t ) ;
1274
1275 if (logger.isLoggable( Level.WARNING )) {
1276 Object [] parameters = null ;
1277 doLog( Level.WARNING, "OMG.typecodeBadRepid",
1278 parameters, OMGSystemException.class, exc ) ;
1279 }
1280
1281 return exc ;
1282 }
1283
1284 public BAD_PARAM typecodeBadRepid( CompletionStatus cs ) {
1285 return typecodeBadRepid( cs, null ) ;
1286 }
1287
1288 public BAD_PARAM typecodeBadRepid( Throwable t ) {
1289 return typecodeBadRepid( CompletionStatus.COMPLETED_NO, t ) ;
1290 }
1291
1292 public BAD_PARAM typecodeBadRepid( ) {
1293 return typecodeBadRepid( CompletionStatus.COMPLETED_NO, null ) ;
1294 }
1295
1296 public static final int TYPECODE_INV_MEMBER = OMGVMCID.value + 17 ;
1297
1298 public BAD_PARAM typecodeInvMember( CompletionStatus cs, Throwable t ) {
1299 BAD_PARAM exc = new BAD_PARAM ( TYPECODE_INV_MEMBER, cs ) ;
1300 if (t != null)
1301 exc.initCause( t ) ;
1302
1303 if (logger.isLoggable( Level.WARNING )) {
1304 Object [] parameters = null ;
1305 doLog( Level.WARNING, "OMG.typecodeInvMember",
1306 parameters, OMGSystemException.class, exc ) ;
1307 }
1308
1309 return exc ;
1310 }
1311
1312 public BAD_PARAM typecodeInvMember( CompletionStatus cs ) {
1313 return typecodeInvMember( cs, null ) ;
1314 }
1315
1316 public BAD_PARAM typecodeInvMember( Throwable t ) {
1317 return typecodeInvMember( CompletionStatus.COMPLETED_NO, t ) ;
1318 }
1319
1320 public BAD_PARAM typecodeInvMember( ) {
1321 return typecodeInvMember( CompletionStatus.COMPLETED_NO, null ) ;
1322 }
1323
1324 public static final int TC_UNION_DUP_LABEL = OMGVMCID.value + 18 ;
1325
1326 public BAD_PARAM tcUnionDupLabel( CompletionStatus cs, Throwable t ) {
1327 BAD_PARAM exc = new BAD_PARAM ( TC_UNION_DUP_LABEL, cs ) ;
1328 if (t != null)
1329 exc.initCause( t ) ;
1330
1331 if (logger.isLoggable( Level.WARNING )) {
1332 Object [] parameters = null ;
1333 doLog( Level.WARNING, "OMG.tcUnionDupLabel",
1334 parameters, OMGSystemException.class, exc ) ;
1335 }
1336
1337 return exc ;
1338 }
1339
1340 public BAD_PARAM tcUnionDupLabel( CompletionStatus cs ) {
1341 return tcUnionDupLabel( cs, null ) ;
1342 }
1343
1344 public BAD_PARAM tcUnionDupLabel( Throwable t ) {
1345 return tcUnionDupLabel( CompletionStatus.COMPLETED_NO, t ) ;
1346 }
1347
1348 public BAD_PARAM tcUnionDupLabel( ) {
1349 return tcUnionDupLabel( CompletionStatus.COMPLETED_NO, null ) ;
1350 }
1351
1352 public static final int TC_UNION_INCOMPATIBLE = OMGVMCID.value + 19 ;
1353
1354 public BAD_PARAM tcUnionIncompatible( CompletionStatus cs, Throwable t ) {
1355 BAD_PARAM exc = new BAD_PARAM ( TC_UNION_INCOMPATIBLE, cs ) ;
1356 if (t != null)
1357 exc.initCause( t ) ;
1358
1359 if (logger.isLoggable( Level.WARNING )) {
1360 Object [] parameters = null ;
1361 doLog( Level.WARNING, "OMG.tcUnionIncompatible",
1362 parameters, OMGSystemException.class, exc ) ;
1363 }
1364
1365 return exc ;
1366 }
1367
1368 public BAD_PARAM tcUnionIncompatible( CompletionStatus cs ) {
1369 return tcUnionIncompatible( cs, null ) ;
1370 }
1371
1372 public BAD_PARAM tcUnionIncompatible( Throwable t ) {
1373 return tcUnionIncompatible( CompletionStatus.COMPLETED_NO, t ) ;
1374 }
1375
1376 public BAD_PARAM tcUnionIncompatible( ) {
1377 return tcUnionIncompatible( CompletionStatus.COMPLETED_NO, null ) ;
1378 }
1379
1380 public static final int TC_UNION_BAD_DISC = OMGVMCID.value + 20 ;
1381
1382 public BAD_PARAM tcUnionBadDisc( CompletionStatus cs, Throwable t ) {
1383 BAD_PARAM exc = new BAD_PARAM ( TC_UNION_BAD_DISC, cs ) ;
1384 if (t != null)
1385 exc.initCause( t ) ;
1386
1387 if (logger.isLoggable( Level.WARNING )) {
1388 Object [] parameters = null ;
1389 doLog( Level.WARNING, "OMG.tcUnionBadDisc",
1390 parameters, OMGSystemException.class, exc ) ;
1391 }
1392
1393 return exc ;
1394 }
1395
1396 public BAD_PARAM tcUnionBadDisc( CompletionStatus cs ) {
1397 return tcUnionBadDisc( cs, null ) ;
1398 }
1399
1400 public BAD_PARAM tcUnionBadDisc( Throwable t ) {
1401 return tcUnionBadDisc( CompletionStatus.COMPLETED_NO, t ) ;
1402 }
1403
1404 public BAD_PARAM tcUnionBadDisc( ) {
1405 return tcUnionBadDisc( CompletionStatus.COMPLETED_NO, null ) ;
1406 }
1407
1408 public static final int SET_EXCEPTION_BAD_ANY = OMGVMCID.value + 21 ;
1409
1410 public BAD_PARAM setExceptionBadAny( CompletionStatus cs, Throwable t ) {
1411 BAD_PARAM exc = new BAD_PARAM ( SET_EXCEPTION_BAD_ANY, cs ) ;
1412 if (t != null)
1413 exc.initCause( t ) ;
1414
1415 if (logger.isLoggable( Level.WARNING )) {
1416 Object [] parameters = null ;
1417 doLog( Level.WARNING, "OMG.setExceptionBadAny",
1418 parameters, OMGSystemException.class, exc ) ;
1419 }
1420
1421 return exc ;
1422 }
1423
1424 public BAD_PARAM setExceptionBadAny( CompletionStatus cs ) {
1425 return setExceptionBadAny( cs, null ) ;
1426 }
1427
1428 public BAD_PARAM setExceptionBadAny( Throwable t ) {
1429 return setExceptionBadAny( CompletionStatus.COMPLETED_NO, t ) ;
1430 }
1431
1432 public BAD_PARAM setExceptionBadAny( ) {
1433 return setExceptionBadAny( CompletionStatus.COMPLETED_NO, null ) ;
1434 }
1435
1436 public static final int SET_EXCEPTION_UNLISTED = OMGVMCID.value + 22 ;
1437
1438 public BAD_PARAM setExceptionUnlisted( CompletionStatus cs, Throwable t ) {
1439 BAD_PARAM exc = new BAD_PARAM ( SET_EXCEPTION_UNLISTED, cs ) ;
1440 if (t != null)
1441 exc.initCause( t ) ;
1442
1443 if (logger.isLoggable( Level.WARNING )) {
1444 Object [] parameters = null ;
1445 doLog( Level.WARNING, "OMG.setExceptionUnlisted",
1446 parameters, OMGSystemException.class, exc ) ;
1447 }
1448
1449 return exc ;
1450 }
1451
1452 public BAD_PARAM setExceptionUnlisted( CompletionStatus cs ) {
1453 return setExceptionUnlisted( cs, null ) ;
1454 }
1455
1456 public BAD_PARAM setExceptionUnlisted( Throwable t ) {
1457 return setExceptionUnlisted( CompletionStatus.COMPLETED_NO, t ) ;
1458 }
1459
1460 public BAD_PARAM setExceptionUnlisted( ) {
1461 return setExceptionUnlisted( CompletionStatus.COMPLETED_NO, null ) ;
1462 }
1463
1464 public static final int NO_CLIENT_WCHAR_CODESET_CTX = OMGVMCID.value + 23 ;
1465
1466 public BAD_PARAM noClientWcharCodesetCtx( CompletionStatus cs, Throwable t ) {
1467 BAD_PARAM exc = new BAD_PARAM ( NO_CLIENT_WCHAR_CODESET_CTX, cs ) ;
1468 if (t != null)
1469 exc.initCause( t ) ;
1470
1471 if (logger.isLoggable( Level.WARNING )) {
1472 Object [] parameters = null ;
1473 doLog( Level.WARNING, "OMG.noClientWcharCodesetCtx",
1474 parameters, OMGSystemException.class, exc ) ;
1475 }
1476
1477 return exc ;
1478 }
1479
1480 public BAD_PARAM noClientWcharCodesetCtx( CompletionStatus cs ) {
1481 return noClientWcharCodesetCtx( cs, null ) ;
1482 }
1483
1484 public BAD_PARAM noClientWcharCodesetCtx( Throwable t ) {
1485 return noClientWcharCodesetCtx( CompletionStatus.COMPLETED_NO, t ) ;
1486 }
1487
1488 public BAD_PARAM noClientWcharCodesetCtx( ) {
1489 return noClientWcharCodesetCtx( CompletionStatus.COMPLETED_NO, null ) ;
1490 }
1491
1492 public static final int ILLEGAL_SERVICE_CONTEXT = OMGVMCID.value + 24 ;
1493
1494 public BAD_PARAM illegalServiceContext( CompletionStatus cs, Throwable t ) {
1495 BAD_PARAM exc = new BAD_PARAM ( ILLEGAL_SERVICE_CONTEXT, cs ) ;
1496 if (t != null)
1497 exc.initCause( t ) ;
1498
1499 if (logger.isLoggable( Level.WARNING )) {
1500 Object [] parameters = null ;
1501 doLog( Level.WARNING, "OMG.illegalServiceContext",
1502 parameters, OMGSystemException.class, exc ) ;
1503 }
1504
1505 return exc ;
1506 }
1507
1508 public BAD_PARAM illegalServiceContext( CompletionStatus cs ) {
1509 return illegalServiceContext( cs, null ) ;
1510 }
1511
1512 public BAD_PARAM illegalServiceContext( Throwable t ) {
1513 return illegalServiceContext( CompletionStatus.COMPLETED_NO, t ) ;
1514 }
1515
1516 public BAD_PARAM illegalServiceContext( ) {
1517 return illegalServiceContext( CompletionStatus.COMPLETED_NO, null ) ;
1518 }
1519
1520 public static final int ENUM_OUT_OF_RANGE = OMGVMCID.value + 25 ;
1521
1522 public BAD_PARAM enumOutOfRange( CompletionStatus cs, Throwable t ) {
1523 BAD_PARAM exc = new BAD_PARAM ( ENUM_OUT_OF_RANGE, cs ) ;
1524 if (t != null)
1525 exc.initCause( t ) ;
1526
1527 if (logger.isLoggable( Level.WARNING )) {
1528 Object [] parameters = null ;
1529 doLog( Level.WARNING, "OMG.enumOutOfRange",
1530 parameters, OMGSystemException.class, exc ) ;
1531 }
1532
1533 return exc ;
1534 }
1535
1536 public BAD_PARAM enumOutOfRange( CompletionStatus cs ) {
1537 return enumOutOfRange( cs, null ) ;
1538 }
1539
1540 public BAD_PARAM enumOutOfRange( Throwable t ) {
1541 return enumOutOfRange( CompletionStatus.COMPLETED_NO, t ) ;
1542 }
1543
1544 public BAD_PARAM enumOutOfRange( ) {
1545 return enumOutOfRange( CompletionStatus.COMPLETED_NO, null ) ;
1546 }
1547
1548 public static final int INVALID_SERVICE_CONTEXT_ID = OMGVMCID.value + 26 ;
1549
1550 public BAD_PARAM invalidServiceContextId( CompletionStatus cs, Throwable t ) {
1551 BAD_PARAM exc = new BAD_PARAM ( INVALID_SERVICE_CONTEXT_ID, cs ) ;
1552 if (t != null)
1553 exc.initCause( t ) ;
1554
1555 if (logger.isLoggable( Level.FINE )) {
1556 Object [] parameters = null ;
1557 doLog( Level.FINE, "OMG.invalidServiceContextId",
1558 parameters, OMGSystemException.class, exc ) ;
1559 }
1560
1561 return exc ;
1562 }
1563
1564 public BAD_PARAM invalidServiceContextId( CompletionStatus cs ) {
1565 return invalidServiceContextId( cs, null ) ;
1566 }
1567
1568 public BAD_PARAM invalidServiceContextId( Throwable t ) {
1569 return invalidServiceContextId( CompletionStatus.COMPLETED_NO, t ) ;
1570 }
1571
1572 public BAD_PARAM invalidServiceContextId( ) {
1573 return invalidServiceContextId( CompletionStatus.COMPLETED_NO, null ) ;
1574 }
1575
1576 public static final int RIR_WITH_NULL_OBJECT = OMGVMCID.value + 27 ;
1577
1578 public BAD_PARAM rirWithNullObject( CompletionStatus cs, Throwable t ) {
1579 BAD_PARAM exc = new BAD_PARAM ( RIR_WITH_NULL_OBJECT, cs ) ;
1580 if (t != null)
1581 exc.initCause( t ) ;
1582
1583 if (logger.isLoggable( Level.WARNING )) {
1584 Object [] parameters = null ;
1585 doLog( Level.WARNING, "OMG.rirWithNullObject",
1586 parameters, OMGSystemException.class, exc ) ;
1587 }
1588
1589 return exc ;
1590 }
1591
1592 public BAD_PARAM rirWithNullObject( CompletionStatus cs ) {
1593 return rirWithNullObject( cs, null ) ;
1594 }
1595
1596 public BAD_PARAM rirWithNullObject( Throwable t ) {
1597 return rirWithNullObject( CompletionStatus.COMPLETED_NO, t ) ;
1598 }
1599
1600 public BAD_PARAM rirWithNullObject( ) {
1601 return rirWithNullObject( CompletionStatus.COMPLETED_NO, null ) ;
1602 }
1603
1604 public static final int INVALID_COMPONENT_ID = OMGVMCID.value + 28 ;
1605
1606 public BAD_PARAM invalidComponentId( CompletionStatus cs, Throwable t, Object arg0) {
1607 BAD_PARAM exc = new BAD_PARAM ( INVALID_COMPONENT_ID, cs ) ;
1608 if (t != null)
1609 exc.initCause( t ) ;
1610
1611 if (logger.isLoggable( Level.FINE )) {
1612 Object [] parameters = new Object [1] ;
1613 parameters[0] = arg0 ;
1614 doLog( Level.FINE, "OMG.invalidComponentId",
1615 parameters, OMGSystemException.class, exc ) ;
1616 }
1617
1618 return exc ;
1619 }
1620
1621 public BAD_PARAM invalidComponentId( CompletionStatus cs, Object arg0) {
1622 return invalidComponentId( cs, null, arg0 ) ;
1623 }
1624
1625 public BAD_PARAM invalidComponentId( Throwable t, Object arg0) {
1626 return invalidComponentId( CompletionStatus.COMPLETED_NO, t, arg0 ) ;
1627 }
1628
1629 public BAD_PARAM invalidComponentId( Object arg0) {
1630 return invalidComponentId( CompletionStatus.COMPLETED_NO, null, arg0 ) ;
1631 }
1632
1633 public static final int INVALID_PROFILE_ID = OMGVMCID.value + 29 ;
1634
1635 public BAD_PARAM invalidProfileId( CompletionStatus cs, Throwable t ) {
1636 BAD_PARAM exc = new BAD_PARAM ( INVALID_PROFILE_ID, cs ) ;
1637 if (t != null)
1638 exc.initCause( t ) ;
1639
1640 if (logger.isLoggable( Level.WARNING )) {
1641 Object [] parameters = null ;
1642 doLog( Level.WARNING, "OMG.invalidProfileId",
1643 parameters, OMGSystemException.class, exc ) ;
1644 }
1645
1646 return exc ;
1647 }
1648
1649 public BAD_PARAM invalidProfileId( CompletionStatus cs ) {
1650 return invalidProfileId( cs, null ) ;
1651 }
1652
1653 public BAD_PARAM invalidProfileId( Throwable t ) {
1654 return invalidProfileId( CompletionStatus.COMPLETED_NO, t ) ;
1655 }
1656
1657 public BAD_PARAM invalidProfileId( ) {
1658 return invalidProfileId( CompletionStatus.COMPLETED_NO, null ) ;
1659 }
1660
1661 public static final int POLICY_TYPE_DUPLICATE = OMGVMCID.value + 30 ;
1662
1663 public BAD_PARAM policyTypeDuplicate( CompletionStatus cs, Throwable t ) {
1664 BAD_PARAM exc = new BAD_PARAM ( POLICY_TYPE_DUPLICATE, cs ) ;
1665 if (t != null)
1666 exc.initCause( t ) ;
1667
1668 if (logger.isLoggable( Level.WARNING )) {
1669 Object [] parameters = null ;
1670 doLog( Level.WARNING, "OMG.policyTypeDuplicate",
1671 parameters, OMGSystemException.class, exc ) ;
1672 }
1673
1674 return exc ;
1675 }
1676
1677 public BAD_PARAM policyTypeDuplicate( CompletionStatus cs ) {
1678 return policyTypeDuplicate( cs, null ) ;
1679 }
1680
1681 public BAD_PARAM policyTypeDuplicate( Throwable t ) {
1682 return policyTypeDuplicate( CompletionStatus.COMPLETED_NO, t ) ;
1683 }
1684
1685 public BAD_PARAM policyTypeDuplicate( ) {
1686 return policyTypeDuplicate( CompletionStatus.COMPLETED_NO, null ) ;
1687 }
1688
1689 public static final int BAD_ONEWAY_DEFINITION = OMGVMCID.value + 31 ;
1690
1691 public BAD_PARAM badOnewayDefinition( CompletionStatus cs, Throwable t ) {
1692 BAD_PARAM exc = new BAD_PARAM ( BAD_ONEWAY_DEFINITION, cs ) ;
1693 if (t != null)
1694 exc.initCause( t ) ;
1695
1696 if (logger.isLoggable( Level.WARNING )) {
1697 Object [] parameters = null ;
1698 doLog( Level.WARNING, "OMG.badOnewayDefinition",
1699 parameters, OMGSystemException.class, exc ) ;
1700 }
1701
1702 return exc ;
1703 }
1704
1705 public BAD_PARAM badOnewayDefinition( CompletionStatus cs ) {
1706 return badOnewayDefinition( cs, null ) ;
1707 }
1708
1709 public BAD_PARAM badOnewayDefinition( Throwable t ) {
1710 return badOnewayDefinition( CompletionStatus.COMPLETED_NO, t ) ;
1711 }
1712
1713 public BAD_PARAM badOnewayDefinition( ) {
1714 return badOnewayDefinition( CompletionStatus.COMPLETED_NO, null ) ;
1715 }
1716
1717 public static final int DII_FOR_IMPLICIT_OPERATION = OMGVMCID.value + 32 ;
1718
1719 public BAD_PARAM diiForImplicitOperation( CompletionStatus cs, Throwable t ) {
1720 BAD_PARAM exc = new BAD_PARAM ( DII_FOR_IMPLICIT_OPERATION, cs ) ;
1721 if (t != null)
1722 exc.initCause( t ) ;
1723
1724 if (logger.isLoggable( Level.WARNING )) {
1725 Object [] parameters = null ;
1726 doLog( Level.WARNING, "OMG.diiForImplicitOperation",
1727 parameters, OMGSystemException.class, exc ) ;
1728 }
1729
1730 return exc ;
1731 }
1732
1733 public BAD_PARAM diiForImplicitOperation( CompletionStatus cs ) {
1734 return diiForImplicitOperation( cs, null ) ;
1735 }
1736
1737 public BAD_PARAM diiForImplicitOperation( Throwable t ) {
1738 return diiForImplicitOperation( CompletionStatus.COMPLETED_NO, t ) ;
1739 }
1740
1741 public BAD_PARAM diiForImplicitOperation( ) {
1742 return diiForImplicitOperation( CompletionStatus.COMPLETED_NO, null ) ;
1743 }
1744
1745 public static final int XA_CALL_INVAL = OMGVMCID.value + 33 ;
1746
1747 public BAD_PARAM xaCallInval( CompletionStatus cs, Throwable t ) {
1748 BAD_PARAM exc = new BAD_PARAM ( XA_CALL_INVAL, cs ) ;
1749 if (t != null)
1750 exc.initCause( t ) ;
1751
1752 if (logger.isLoggable( Level.WARNING )) {
1753 Object [] parameters = null ;
1754 doLog( Level.WARNING, "OMG.xaCallInval",
1755 parameters, OMGSystemException.class, exc ) ;
1756 }
1757
1758 return exc ;
1759 }
1760
1761 public BAD_PARAM xaCallInval( CompletionStatus cs ) {
1762 return xaCallInval( cs, null ) ;
1763 }
1764
1765 public BAD_PARAM xaCallInval( Throwable t ) {
1766 return xaCallInval( CompletionStatus.COMPLETED_NO, t ) ;
1767 }
1768
1769 public BAD_PARAM xaCallInval( ) {
1770 return xaCallInval( CompletionStatus.COMPLETED_NO, null ) ;
1771 }
1772
1773 public static final int UNION_BAD_DISCRIMINATOR = OMGVMCID.value + 34 ;
1774
1775 public BAD_PARAM unionBadDiscriminator( CompletionStatus cs, Throwable t ) {
1776 BAD_PARAM exc = new BAD_PARAM ( UNION_BAD_DISCRIMINATOR, cs ) ;
1777 if (t != null)
1778 exc.initCause( t ) ;
1779
1780 if (logger.isLoggable( Level.WARNING )) {
1781 Object [] parameters = null ;
1782 doLog( Level.WARNING, "OMG.unionBadDiscriminator",
1783 parameters, OMGSystemException.class, exc ) ;
1784 }
1785
1786 return exc ;
1787 }
1788
1789 public BAD_PARAM unionBadDiscriminator( CompletionStatus cs ) {
1790 return unionBadDiscriminator( cs, null ) ;
1791 }
1792
1793 public BAD_PARAM unionBadDiscriminator( Throwable t ) {
1794 return unionBadDiscriminator( CompletionStatus.COMPLETED_NO, t ) ;
1795 }
1796
1797 public BAD_PARAM unionBadDiscriminator( ) {
1798 return unionBadDiscriminator( CompletionStatus.COMPLETED_NO, null ) ;
1799 }
1800
1801 public static final int CTX_ILLEGAL_PROPERTY_NAME = OMGVMCID.value + 35 ;
1802
1803 public BAD_PARAM ctxIllegalPropertyName( CompletionStatus cs, Throwable t ) {
1804 BAD_PARAM exc = new BAD_PARAM ( CTX_ILLEGAL_PROPERTY_NAME, cs ) ;
1805 if (t != null)
1806 exc.initCause( t ) ;
1807
1808 if (logger.isLoggable( Level.WARNING )) {
1809 Object [] parameters = null ;
1810 doLog( Level.WARNING, "OMG.ctxIllegalPropertyName",
1811 parameters, OMGSystemException.class, exc ) ;
1812 }
1813
1814 return exc ;
1815 }
1816
1817 public BAD_PARAM ctxIllegalPropertyName( CompletionStatus cs ) {
1818 return ctxIllegalPropertyName( cs, null ) ;
1819 }
1820
1821 public BAD_PARAM ctxIllegalPropertyName( Throwable t ) {
1822 return ctxIllegalPropertyName( CompletionStatus.COMPLETED_NO, t ) ;
1823 }
1824
1825 public BAD_PARAM ctxIllegalPropertyName( ) {
1826 return ctxIllegalPropertyName( CompletionStatus.COMPLETED_NO, null ) ;
1827 }
1828
1829 public static final int CTX_ILLEGAL_SEARCH_STRING = OMGVMCID.value + 36 ;
1830
1831 public BAD_PARAM ctxIllegalSearchString( CompletionStatus cs, Throwable t ) {
1832 BAD_PARAM exc = new BAD_PARAM ( CTX_ILLEGAL_SEARCH_STRING, cs ) ;
1833 if (t != null)
1834 exc.initCause( t ) ;
1835
1836 if (logger.isLoggable( Level.WARNING )) {
1837 Object [] parameters = null ;
1838 doLog( Level.WARNING, "OMG.ctxIllegalSearchString",
1839 parameters, OMGSystemException.class, exc ) ;
1840 }
1841
1842 return exc ;
1843 }
1844
1845 public BAD_PARAM ctxIllegalSearchString( CompletionStatus cs ) {
1846 return ctxIllegalSearchString( cs, null ) ;
1847 }
1848
1849 public BAD_PARAM ctxIllegalSearchString( Throwable t ) {
1850 return ctxIllegalSearchString( CompletionStatus.COMPLETED_NO, t ) ;
1851 }
1852
1853 public BAD_PARAM ctxIllegalSearchString( ) {
1854 return ctxIllegalSearchString( CompletionStatus.COMPLETED_NO, null ) ;
1855 }
1856
1857 public static final int CTX_ILLEGAL_NAME = OMGVMCID.value + 37 ;
1858
1859 public BAD_PARAM ctxIllegalName( CompletionStatus cs, Throwable t ) {
1860 BAD_PARAM exc = new BAD_PARAM ( CTX_ILLEGAL_NAME, cs ) ;
1861 if (t != null)
1862 exc.initCause( t ) ;
1863
1864 if (logger.isLoggable( Level.WARNING )) {
1865 Object [] parameters = null ;
1866 doLog( Level.WARNING, "OMG.ctxIllegalName",
1867 parameters, OMGSystemException.class, exc ) ;
1868 }
1869
1870 return exc ;
1871 }
1872
1873 public BAD_PARAM ctxIllegalName( CompletionStatus cs ) {
1874 return ctxIllegalName( cs, null ) ;
1875 }
1876
1877 public BAD_PARAM ctxIllegalName( Throwable t ) {
1878 return ctxIllegalName( CompletionStatus.COMPLETED_NO, t ) ;
1879 }
1880
1881 public BAD_PARAM ctxIllegalName( ) {
1882 return ctxIllegalName( CompletionStatus.COMPLETED_NO, null ) ;
1883 }
1884
1885 public static final int CTX_NON_EMPTY = OMGVMCID.value + 38 ;
1886
1887 public BAD_PARAM ctxNonEmpty( CompletionStatus cs, Throwable t ) {
1888 BAD_PARAM exc = new BAD_PARAM ( CTX_NON_EMPTY, cs ) ;
1889 if (t != null)
1890 exc.initCause( t ) ;
1891
1892 if (logger.isLoggable( Level.WARNING )) {
1893 Object [] parameters = null ;
1894 doLog( Level.WARNING, "OMG.ctxNonEmpty",
1895 parameters, OMGSystemException.class, exc ) ;
1896 }
1897
1898 return exc ;
1899 }
1900
1901 public BAD_PARAM ctxNonEmpty( CompletionStatus cs ) {
1902 return ctxNonEmpty( cs, null ) ;
1903 }
1904
1905 public BAD_PARAM ctxNonEmpty( Throwable t ) {
1906 return ctxNonEmpty( CompletionStatus.COMPLETED_NO, t ) ;
1907 }
1908
1909 public BAD_PARAM ctxNonEmpty( ) {
1910 return ctxNonEmpty( CompletionStatus.COMPLETED_NO, null ) ;
1911 }
1912
1913 public static final int INVALID_STREAM_FORMAT_VERSION = OMGVMCID.value + 39 ;
1914
1915 public BAD_PARAM invalidStreamFormatVersion( CompletionStatus cs, Throwable t, Object arg0) {
1916 BAD_PARAM exc = new BAD_PARAM ( INVALID_STREAM_FORMAT_VERSION, cs ) ;
1917 if (t != null)
1918 exc.initCause( t ) ;
1919
1920 if (logger.isLoggable( Level.WARNING )) {
1921 Object [] parameters = new Object [1] ;
1922 parameters[0] = arg0 ;
1923 doLog( Level.WARNING, "OMG.invalidStreamFormatVersion",
1924 parameters, OMGSystemException.class, exc ) ;
1925 }
1926
1927 return exc ;
1928 }
1929
1930 public BAD_PARAM invalidStreamFormatVersion( CompletionStatus cs, Object arg0) {
1931 return invalidStreamFormatVersion( cs, null, arg0 ) ;
1932 }
1933
1934 public BAD_PARAM invalidStreamFormatVersion( Throwable t, Object arg0) {
1935 return invalidStreamFormatVersion( CompletionStatus.COMPLETED_NO, t, arg0 ) ;
1936 }
1937
1938 public BAD_PARAM invalidStreamFormatVersion( Object arg0) {
1939 return invalidStreamFormatVersion( CompletionStatus.COMPLETED_NO, null, arg0 ) ;
1940 }
1941
1942 public static final int NOT_A_VALUEOUTPUTSTREAM = OMGVMCID.value + 40 ;
1943
1944 public BAD_PARAM notAValueoutputstream( CompletionStatus cs, Throwable t ) {
1945 BAD_PARAM exc = new BAD_PARAM ( NOT_A_VALUEOUTPUTSTREAM, cs ) ;
1946 if (t != null)
1947 exc.initCause( t ) ;
1948
1949 if (logger.isLoggable( Level.WARNING )) {
1950 Object [] parameters = null ;
1951 doLog( Level.WARNING, "OMG.notAValueoutputstream",
1952 parameters, OMGSystemException.class, exc ) ;
1953 }
1954
1955 return exc ;
1956 }
1957
1958 public BAD_PARAM notAValueoutputstream( CompletionStatus cs ) {
1959 return notAValueoutputstream( cs, null ) ;
1960 }
1961
1962 public BAD_PARAM notAValueoutputstream( Throwable t ) {
1963 return notAValueoutputstream( CompletionStatus.COMPLETED_NO, t ) ;
1964 }
1965
1966 public BAD_PARAM notAValueoutputstream( ) {
1967 return notAValueoutputstream( CompletionStatus.COMPLETED_NO, null ) ;
1968 }
1969
1970 public static final int NOT_A_VALUEINPUTSTREAM = OMGVMCID.value + 41 ;
1971
1972 public BAD_PARAM notAValueinputstream( CompletionStatus cs, Throwable t ) {
1973 BAD_PARAM exc = new BAD_PARAM ( NOT_A_VALUEINPUTSTREAM, cs ) ;
1974 if (t != null)
1975 exc.initCause( t ) ;
1976
1977 if (logger.isLoggable( Level.WARNING )) {
1978 Object [] parameters = null ;
1979 doLog( Level.WARNING, "OMG.notAValueinputstream",
1980 parameters, OMGSystemException.class, exc ) ;
1981 }
1982
1983 return exc ;
1984 }
1985
1986 public BAD_PARAM notAValueinputstream( CompletionStatus cs ) {
1987 return notAValueinputstream( cs, null ) ;
1988 }
1989
1990 public BAD_PARAM notAValueinputstream( Throwable t ) {
1991 return notAValueinputstream( CompletionStatus.COMPLETED_NO, t ) ;
1992 }
1993
1994 public BAD_PARAM notAValueinputstream( ) {
1995 return notAValueinputstream( CompletionStatus.COMPLETED_NO, null ) ;
1996 }
1997
1998
2002 public static final int MARSHALL_INCOMPLETE_TYPECODE = OMGVMCID.value + 1 ;
2003
2004 public BAD_TYPECODE marshallIncompleteTypecode( CompletionStatus cs, Throwable t ) {
2005 BAD_TYPECODE exc = new BAD_TYPECODE ( MARSHALL_INCOMPLETE_TYPECODE, cs ) ;
2006 if (t != null)
2007 exc.initCause( t ) ;
2008
2009 if (logger.isLoggable( Level.WARNING )) {
2010 Object [] parameters = null ;
2011 doLog( Level.WARNING, "OMG.marshallIncompleteTypecode",
2012 parameters, OMGSystemException.class, exc ) ;
2013 }
2014
2015 return exc ;
2016 }
2017
2018 public BAD_TYPECODE marshallIncompleteTypecode( CompletionStatus cs ) {
2019 return marshallIncompleteTypecode( cs, null ) ;
2020 }
2021
2022 public BAD_TYPECODE marshallIncompleteTypecode( Throwable t ) {
2023 return marshallIncompleteTypecode( CompletionStatus.COMPLETED_NO, t ) ;
2024 }
2025
2026 public BAD_TYPECODE marshallIncompleteTypecode( ) {
2027 return marshallIncompleteTypecode( CompletionStatus.COMPLETED_NO, null ) ;
2028 }
2029
2030 public static final int BAD_MEMBER_TYPECODE = OMGVMCID.value + 2 ;
2031
2032 public BAD_TYPECODE badMemberTypecode( CompletionStatus cs, Throwable t ) {
2033 BAD_TYPECODE exc = new BAD_TYPECODE ( BAD_MEMBER_TYPECODE, cs ) ;
2034 if (t != null)
2035 exc.initCause( t ) ;
2036
2037 if (logger.isLoggable( Level.WARNING )) {
2038 Object [] parameters = null ;
2039 doLog( Level.WARNING, "OMG.badMemberTypecode",
2040 parameters, OMGSystemException.class, exc ) ;
2041 }
2042
2043 return exc ;
2044 }
2045
2046 public BAD_TYPECODE badMemberTypecode( CompletionStatus cs ) {
2047 return badMemberTypecode( cs, null ) ;
2048 }
2049
2050 public BAD_TYPECODE badMemberTypecode( Throwable t ) {
2051 return badMemberTypecode( CompletionStatus.COMPLETED_NO, t ) ;
2052 }
2053
2054 public BAD_TYPECODE badMemberTypecode( ) {
2055 return badMemberTypecode( CompletionStatus.COMPLETED_NO, null ) ;
2056 }
2057
2058 public static final int ILLEGAL_PARAMETER = OMGVMCID.value + 3 ;
2059
2060 public BAD_TYPECODE illegalParameter( CompletionStatus cs, Throwable t ) {
2061 BAD_TYPECODE exc = new BAD_TYPECODE ( ILLEGAL_PARAMETER, cs ) ;
2062 if (t != null)
2063 exc.initCause( t ) ;
2064
2065 if (logger.isLoggable( Level.WARNING )) {
2066 Object [] parameters = null ;
2067 doLog( Level.WARNING, "OMG.illegalParameter",
2068 parameters, OMGSystemException.class, exc ) ;
2069 }
2070
2071 return exc ;
2072 }
2073
2074 public BAD_TYPECODE illegalParameter( CompletionStatus cs ) {
2075 return illegalParameter( cs, null ) ;
2076 }
2077
2078 public BAD_TYPECODE illegalParameter( Throwable t ) {
2079 return illegalParameter( CompletionStatus.COMPLETED_NO, t ) ;
2080 }
2081
2082 public BAD_TYPECODE illegalParameter( ) {
2083 return illegalParameter( CompletionStatus.COMPLETED_NO, null ) ;
2084 }
2085
2086
2090 public static final int CHAR_NOT_IN_CODESET = OMGVMCID.value + 1 ;
2091
2092 public DATA_CONVERSION charNotInCodeset( CompletionStatus cs, Throwable t ) {
2093 DATA_CONVERSION exc = new DATA_CONVERSION ( CHAR_NOT_IN_CODESET, cs ) ;
2094 if (t != null)
2095 exc.initCause( t ) ;
2096
2097 if (logger.isLoggable( Level.WARNING )) {
2098 Object [] parameters = null ;
2099 doLog( Level.WARNING, "OMG.charNotInCodeset",
2100 parameters, OMGSystemException.class, exc ) ;
2101 }
2102
2103 return exc ;
2104 }
2105
2106 public DATA_CONVERSION charNotInCodeset( CompletionStatus cs ) {
2107 return charNotInCodeset( cs, null ) ;
2108 }
2109
2110 public DATA_CONVERSION charNotInCodeset( Throwable t ) {
2111 return charNotInCodeset( CompletionStatus.COMPLETED_NO, t ) ;
2112 }
2113
2114 public DATA_CONVERSION charNotInCodeset( ) {
2115 return charNotInCodeset( CompletionStatus.COMPLETED_NO, null ) ;
2116 }
2117
2118 public static final int PRIORITY_MAP_FAILRE = OMGVMCID.value + 2 ;
2119
2120 public DATA_CONVERSION priorityMapFailre( CompletionStatus cs, Throwable t ) {
2121 DATA_CONVERSION exc = new DATA_CONVERSION ( PRIORITY_MAP_FAILRE, cs ) ;
2122 if (t != null)
2123 exc.initCause( t ) ;
2124
2125 if (logger.isLoggable( Level.WARNING )) {
2126 Object [] parameters = null ;
2127 doLog( Level.WARNING, "OMG.priorityMapFailre",
2128 parameters, OMGSystemException.class, exc ) ;
2129 }
2130
2131 return exc ;
2132 }
2133
2134 public DATA_CONVERSION priorityMapFailre( CompletionStatus cs ) {
2135 return priorityMapFailre( cs, null ) ;
2136 }
2137
2138 public DATA_CONVERSION priorityMapFailre( Throwable t ) {
2139 return priorityMapFailre( CompletionStatus.COMPLETED_NO, t ) ;
2140 }
2141
2142 public DATA_CONVERSION priorityMapFailre( ) {
2143 return priorityMapFailre( CompletionStatus.COMPLETED_NO, null ) ;
2144 }
2145
2146
2150 public static final int NO_USABLE_PROFILE = OMGVMCID.value + 1 ;
2151
2152 public IMP_LIMIT noUsableProfile( CompletionStatus cs, Throwable t ) {
2153 IMP_LIMIT exc = new IMP_LIMIT ( NO_USABLE_PROFILE, cs ) ;
2154 if (t != null)
2155 exc.initCause( t ) ;
2156
2157 if (logger.isLoggable( Level.WARNING )) {
2158 Object [] parameters = null ;
2159 doLog( Level.WARNING, "OMG.noUsableProfile",
2160 parameters, OMGSystemException.class, exc ) ;
2161 }
2162
2163 return exc ;
2164 }
2165
2166 public IMP_LIMIT noUsableProfile( CompletionStatus cs ) {
2167 return noUsableProfile( cs, null ) ;
2168 }
2169
2170 public IMP_LIMIT noUsableProfile( Throwable t ) {
2171 return noUsableProfile( CompletionStatus.COMPLETED_NO, t ) ;
2172 }
2173
2174 public IMP_LIMIT noUsableProfile( ) {
2175 return noUsableProfile( CompletionStatus.COMPLETED_NO, null ) ;
2176 }
2177
2178
2182 public static final int PRIORITY_RANGE_RESTRICT = OMGVMCID.value + 1 ;
2183
2184 public INITIALIZE priorityRangeRestrict( CompletionStatus cs, Throwable t ) {
2185 INITIALIZE exc = new INITIALIZE ( PRIORITY_RANGE_RESTRICT, cs ) ;
2186 if (t != null)
2187 exc.initCause( t ) ;
2188
2189 if (logger.isLoggable( Level.WARNING )) {
2190 Object [] parameters = null ;
2191 doLog( Level.WARNING, "OMG.priorityRangeRestrict",
2192 parameters, OMGSystemException.class, exc ) ;
2193 }
2194
2195 return exc ;
2196 }
2197
2198 public INITIALIZE priorityRangeRestrict( CompletionStatus cs ) {
2199 return priorityRangeRestrict( cs, null ) ;
2200 }
2201
2202 public INITIALIZE priorityRangeRestrict( Throwable t ) {
2203 return priorityRangeRestrict( CompletionStatus.COMPLETED_NO, t ) ;
2204 }
2205
2206 public INITIALIZE priorityRangeRestrict( ) {
2207 return priorityRangeRestrict( CompletionStatus.COMPLETED_NO, null ) ;
2208 }
2209
2210
2214 public static final int NO_SERVER_WCHAR_CODESET_CMP = OMGVMCID.value + 1 ;
2215
2216 public INV_OBJREF noServerWcharCodesetCmp( CompletionStatus cs, Throwable t ) {
2217 INV_OBJREF exc = new INV_OBJREF ( NO_SERVER_WCHAR_CODESET_CMP, cs ) ;
2218 if (t != null)
2219 exc.initCause( t ) ;
2220
2221 if (logger.isLoggable( Level.WARNING )) {
2222 Object [] parameters = null ;
2223 doLog( Level.WARNING, "OMG.noServerWcharCodesetCmp",
2224 parameters, OMGSystemException.class, exc ) ;
2225 }
2226
2227 return exc ;
2228 }
2229
2230 public INV_OBJREF noServerWcharCodesetCmp( CompletionStatus cs ) {
2231 return noServerWcharCodesetCmp( cs, null ) ;
2232 }
2233
2234 public INV_OBJREF noServerWcharCodesetCmp( Throwable t ) {
2235 return noServerWcharCodesetCmp( CompletionStatus.COMPLETED_NO, t ) ;
2236 }
2237
2238 public INV_OBJREF noServerWcharCodesetCmp( ) {
2239 return noServerWcharCodesetCmp( CompletionStatus.COMPLETED_NO, null ) ;
2240 }
2241
2242 public static final int CODESET_COMPONENT_REQUIRED = OMGVMCID.value + 2 ;
2243
2244 public INV_OBJREF codesetComponentRequired( CompletionStatus cs, Throwable t ) {
2245 INV_OBJREF exc = new INV_OBJREF ( CODESET_COMPONENT_REQUIRED, cs ) ;
2246 if (t != null)
2247 exc.initCause( t ) ;
2248
2249 if (logger.isLoggable( Level.WARNING )) {
2250 Object [] parameters = null ;
2251 doLog( Level.WARNING, "OMG.codesetComponentRequired",
2252 parameters, OMGSystemException.class, exc ) ;
2253 }
2254
2255 return exc ;
2256 }
2257
2258 public INV_OBJREF codesetComponentRequired( CompletionStatus cs ) {
2259 return codesetComponentRequired( cs, null ) ;
2260 }
2261
2262 public INV_OBJREF codesetComponentRequired( Throwable t ) {
2263 return codesetComponentRequired( CompletionStatus.COMPLETED_NO, t ) ;
2264 }
2265
2266 public INV_OBJREF codesetComponentRequired( ) {
2267 return codesetComponentRequired( CompletionStatus.COMPLETED_NO, null ) ;
2268 }
2269
2270
2274 public static final int IOR_POLICY_RECONCILE_ERROR = OMGVMCID.value + 1 ;
2275
2276 public INV_POLICY iorPolicyReconcileError( CompletionStatus cs, Throwable t ) {
2277 INV_POLICY exc = new INV_POLICY ( IOR_POLICY_RECONCILE_ERROR, cs ) ;
2278 if (t != null)
2279 exc.initCause( t ) ;
2280
2281 if (logger.isLoggable( Level.WARNING )) {
2282 Object [] parameters = null ;
2283 doLog( Level.WARNING, "OMG.iorPolicyReconcileError",
2284 parameters, OMGSystemException.class, exc ) ;
2285 }
2286
2287 return exc ;
2288 }
2289
2290 public INV_POLICY iorPolicyReconcileError( CompletionStatus cs ) {
2291 return iorPolicyReconcileError( cs, null ) ;
2292 }
2293
2294 public INV_POLICY iorPolicyReconcileError( Throwable t ) {
2295 return iorPolicyReconcileError( CompletionStatus.COMPLETED_NO, t ) ;
2296 }
2297
2298 public INV_POLICY iorPolicyReconcileError( ) {
2299 return iorPolicyReconcileError( CompletionStatus.COMPLETED_NO, null ) ;
2300 }
2301
2302 public static final int POLICY_UNKNOWN = OMGVMCID.value + 2 ;
2303
2304 public INV_POLICY policyUnknown( CompletionStatus cs, Throwable t ) {
2305 INV_POLICY exc = new INV_POLICY ( POLICY_UNKNOWN, cs ) ;
2306 if (t != null)
2307 exc.initCause( t ) ;
2308
2309 if (logger.isLoggable( Level.WARNING )) {
2310 Object [] parameters = null ;
2311 doLog( Level.WARNING, "OMG.policyUnknown",
2312 parameters, OMGSystemException.class, exc ) ;
2313 }
2314
2315 return exc ;
2316 }
2317
2318 public INV_POLICY policyUnknown( CompletionStatus cs ) {
2319 return policyUnknown( cs, null ) ;
2320 }
2321
2322 public INV_POLICY policyUnknown( Throwable t ) {
2323 return policyUnknown( CompletionStatus.COMPLETED_NO, t ) ;
2324 }
2325
2326 public INV_POLICY policyUnknown( ) {
2327 return policyUnknown( CompletionStatus.COMPLETED_NO, null ) ;
2328 }
2329
2330 public static final int NO_POLICY_FACTORY = OMGVMCID.value + 3 ;
2331
2332 public INV_POLICY noPolicyFactory( CompletionStatus cs, Throwable t ) {
2333 INV_POLICY exc = new INV_POLICY ( NO_POLICY_FACTORY, cs ) ;
2334 if (t != null)
2335 exc.initCause( t ) ;
2336
2337 if (logger.isLoggable( Level.WARNING )) {
2338 Object [] parameters = null ;
2339 doLog( Level.WARNING, "OMG.noPolicyFactory",
2340 parameters, OMGSystemException.class, exc ) ;
2341 }
2342
2343 return exc ;
2344 }
2345
2346 public INV_POLICY noPolicyFactory( CompletionStatus cs ) {
2347 return noPolicyFactory( cs, null ) ;
2348 }
2349
2350 public INV_POLICY noPolicyFactory( Throwable t ) {
2351 return noPolicyFactory( CompletionStatus.COMPLETED_NO, t ) ;
2352 }
2353
2354 public INV_POLICY noPolicyFactory( ) {
2355 return noPolicyFactory( CompletionStatus.COMPLETED_NO, null ) ;
2356 }
2357
2358
2362 public static final int XA_RMERR = OMGVMCID.value + 1 ;
2363
2364 public INTERNAL xaRmerr( CompletionStatus cs, Throwable t ) {
2365 INTERNAL exc = new INTERNAL ( XA_RMERR, cs ) ;
2366 if (t != null)
2367 exc.initCause( t ) ;
2368
2369 if (logger.isLoggable( Level.WARNING )) {
2370 Object [] parameters = null ;
2371 doLog( Level.WARNING, "OMG.xaRmerr",
2372 parameters, OMGSystemException.class, exc ) ;
2373 }
2374
2375 return exc ;
2376 }
2377
2378 public INTERNAL xaRmerr( CompletionStatus cs ) {
2379 return xaRmerr( cs, null ) ;
2380 }
2381
2382 public INTERNAL xaRmerr( Throwable t ) {
2383 return xaRmerr( CompletionStatus.COMPLETED_NO, t ) ;
2384 }
2385
2386 public INTERNAL xaRmerr( ) {
2387 return xaRmerr( CompletionStatus.COMPLETED_NO, null ) ;
2388 }
2389
2390 public static final int XA_RMFAIL = OMGVMCID.value + 2 ;
2391
2392 public INTERNAL xaRmfail( CompletionStatus cs, Throwable t ) {
2393 INTERNAL exc = new INTERNAL ( XA_RMFAIL, cs ) ;
2394 if (t != null)
2395 exc.initCause( t ) ;
2396
2397 if (logger.isLoggable( Level.WARNING )) {
2398 Object [] parameters = null ;
2399 doLog( Level.WARNING, "OMG.xaRmfail",
2400 parameters, OMGSystemException.class, exc ) ;
2401 }
2402
2403 return exc ;
2404 }
2405
2406 public INTERNAL xaRmfail( CompletionStatus cs ) {
2407 return xaRmfail( cs, null ) ;
2408 }
2409
2410 public INTERNAL xaRmfail( Throwable t ) {
2411 return xaRmfail( CompletionStatus.COMPLETED_NO, t ) ;
2412 }
2413
2414 public INTERNAL xaRmfail( ) {
2415 return xaRmfail( CompletionStatus.COMPLETED_NO, null ) ;
2416 }
2417
2418
2422 public static final int NO_IR = OMGVMCID.value + 1 ;
2423
2424 public INTF_REPOS noIr( CompletionStatus cs, Throwable t ) {
2425 INTF_REPOS exc = new INTF_REPOS ( NO_IR, cs ) ;
2426 if (t != null)
2427 exc.initCause( t ) ;
2428
2429 if (logger.isLoggable( Level.WARNING )) {
2430 Object [] parameters = null ;
2431 doLog( Level.WARNING, "OMG.noIr",
2432 parameters, OMGSystemException.class, exc ) ;
2433 }
2434
2435 return exc ;
2436 }
2437
2438 public INTF_REPOS noIr( CompletionStatus cs ) {
2439 return noIr( cs, null ) ;
2440 }
2441
2442 public INTF_REPOS noIr( Throwable t ) {
2443 return noIr( CompletionStatus.COMPLETED_NO, t ) ;
2444 }
2445
2446 public INTF_REPOS noIr( ) {
2447 return noIr( CompletionStatus.COMPLETED_NO, null ) ;
2448 }
2449
2450 public static final int NO_INTERFACE_IN_IR = OMGVMCID.value + 2 ;
2451
2452 public INTF_REPOS noInterfaceInIr( CompletionStatus cs, Throwable t ) {
2453 INTF_REPOS exc = new INTF_REPOS ( NO_INTERFACE_IN_IR, cs ) ;
2454 if (t != null)
2455 exc.initCause( t ) ;
2456
2457 if (logger.isLoggable( Level.WARNING )) {
2458 Object [] parameters = null ;
2459 doLog( Level.WARNING, "OMG.noInterfaceInIr",
2460 parameters, OMGSystemException.class, exc ) ;
2461 }
2462
2463 return exc ;
2464 }
2465
2466 public INTF_REPOS noInterfaceInIr( CompletionStatus cs ) {
2467 return noInterfaceInIr( cs, null ) ;
2468 }
2469
2470 public INTF_REPOS noInterfaceInIr( Throwable t ) {
2471 return noInterfaceInIr( CompletionStatus.COMPLETED_NO, t ) ;
2472 }
2473
2474 public INTF_REPOS noInterfaceInIr( ) {
2475 return noInterfaceInIr( CompletionStatus.COMPLETED_NO, null ) ;
2476 }
2477
2478
2482 public static final int UNABLE_LOCATE_VALUE_FACTORY = OMGVMCID.value + 1 ;
2483
2484 public MARSHAL unableLocateValueFactory( CompletionStatus cs, Throwable t ) {
2485 MARSHAL exc = new MARSHAL ( UNABLE_LOCATE_VALUE_FACTORY, cs ) ;
2486 if (t != null)
2487 exc.initCause( t ) ;
2488
2489 if (logger.isLoggable( Level.FINE )) {
2490 Object [] parameters = null ;
2491 doLog( Level.FINE, "OMG.unableLocateValueFactory",
2492 parameters, OMGSystemException.class, exc ) ;
2493 }
2494
2495 return exc ;
2496 }
2497
2498 public MARSHAL unableLocateValueFactory( CompletionStatus cs ) {
2499 return unableLocateValueFactory( cs, null ) ;
2500 }
2501
2502 public MARSHAL unableLocateValueFactory( Throwable t ) {
2503 return unableLocateValueFactory( CompletionStatus.COMPLETED_NO, t ) ;
2504 }
2505
2506 public MARSHAL unableLocateValueFactory( ) {
2507 return unableLocateValueFactory( CompletionStatus.COMPLETED_NO, null ) ;
2508 }
2509
2510 public static final int SET_RESULT_BEFORE_CTX = OMGVMCID.value + 2 ;
2511
2512 public MARSHAL setResultBeforeCtx( CompletionStatus cs, Throwable t ) {
2513 MARSHAL exc = new MARSHAL ( SET_RESULT_BEFORE_CTX, cs ) ;
2514 if (t != null)
2515 exc.initCause( t ) ;
2516
2517 if (logger.isLoggable( Level.WARNING )) {
2518 Object [] parameters = null ;
2519 doLog( Level.WARNING, "OMG.setResultBeforeCtx",
2520 parameters, OMGSystemException.class, exc ) ;
2521 }
2522
2523 return exc ;
2524 }
2525
2526 public MARSHAL setResultBeforeCtx( CompletionStatus cs ) {
2527 return setResultBeforeCtx( cs, null ) ;
2528 }
2529
2530 public MARSHAL setResultBeforeCtx( Throwable t ) {
2531 return setResultBeforeCtx( CompletionStatus.COMPLETED_NO, t ) ;
2532 }
2533
2534 public MARSHAL setResultBeforeCtx( ) {
2535 return setResultBeforeCtx( CompletionStatus.COMPLETED_NO, null ) ;
2536 }
2537
2538 public static final int BAD_NVLIST = OMGVMCID.value + 3 ;
2539
2540 public MARSHAL badNvlist( CompletionStatus cs, Throwable t ) {
2541 MARSHAL exc = new MARSHAL ( BAD_NVLIST, cs ) ;
2542 if (t != null)
2543 exc.initCause( t ) ;
2544
2545 if (logger.isLoggable( Level.WARNING )) {
2546 Object [] parameters = null ;
2547 doLog( Level.WARNING, "OMG.badNvlist",
2548 parameters, OMGSystemException.class, exc ) ;
2549 }
2550
2551 return exc ;
2552 }
2553
2554 public MARSHAL badNvlist( CompletionStatus cs ) {
2555 return badNvlist( cs, null ) ;
2556 }
2557
2558 public MARSHAL badNvlist( Throwable t ) {
2559 return badNvlist( CompletionStatus.COMPLETED_NO, t ) ;
2560 }
2561
2562 public MARSHAL badNvlist( ) {
2563 return badNvlist( CompletionStatus.COMPLETED_NO, null ) ;
2564 }
2565
2566 public static final int NOT_AN_OBJECT_IMPL = OMGVMCID.value + 4 ;
2567
2568 public MARSHAL notAnObjectImpl( CompletionStatus cs, Throwable t ) {
2569 MARSHAL exc = new MARSHAL ( NOT_AN_OBJECT_IMPL, cs ) ;
2570 if (t != null)
2571 exc.initCause( t ) ;
2572
2573 if (logger.isLoggable( Level.WARNING )) {
2574 Object [] parameters = null ;
2575 doLog( Level.WARNING, "OMG.notAnObjectImpl",
2576 parameters, OMGSystemException.class, exc ) ;
2577 }
2578
2579 return exc ;
2580 }
2581
2582 public MARSHAL notAnObjectImpl( CompletionStatus cs ) {
2583 return notAnObjectImpl( cs, null ) ;
2584 }
2585
2586 public MARSHAL notAnObjectImpl( Throwable t ) {
2587 return notAnObjectImpl( CompletionStatus.COMPLETED_NO, t ) ;
2588 }
2589
2590 public MARSHAL notAnObjectImpl( ) {
2591 return notAnObjectImpl( CompletionStatus.COMPLETED_NO, null ) ;
2592 }
2593
2594 public static final int WCHAR_BAD_GIOP_VERSION_SENT = OMGVMCID.value + 5 ;
2595
2596 public MARSHAL wcharBadGiopVersionSent( CompletionStatus cs, Throwable t ) {
2597 MARSHAL exc = new MARSHAL ( WCHAR_BAD_GIOP_VERSION_SENT, cs ) ;
2598 if (t != null)
2599 exc.initCause( t ) ;
2600
2601 if (logger.isLoggable( Level.WARNING )) {
2602 Object [] parameters = null ;
2603 doLog( Level.WARNING, "OMG.wcharBadGiopVersionSent",
2604 parameters, OMGSystemException.class, exc ) ;
2605 }
2606
2607 return exc ;
2608 }
2609
2610 public MARSHAL wcharBadGiopVersionSent( CompletionStatus cs ) {
2611 return wcharBadGiopVersionSent( cs, null ) ;
2612 }
2613
2614 public MARSHAL wcharBadGiopVersionSent( Throwable t ) {
2615 return wcharBadGiopVersionSent( CompletionStatus.COMPLETED_NO, t ) ;
2616 }
2617
2618 public MARSHAL wcharBadGiopVersionSent( ) {
2619 return wcharBadGiopVersionSent( CompletionStatus.COMPLETED_NO, null ) ;
2620 }
2621
2622 public static final int WCHAR_BAD_GIOP_VERSION_RETURNED = OMGVMCID.value + 6 ;
2623
2624 public MARSHAL wcharBadGiopVersionReturned( CompletionStatus cs, Throwable t ) {
2625 MARSHAL exc = new MARSHAL ( WCHAR_BAD_GIOP_VERSION_RETURNED, cs ) ;
2626 if (t != null)
2627 exc.initCause( t ) ;
2628
2629 if (logger.isLoggable( Level.WARNING )) {
2630 Object [] parameters = null ;
2631 doLog( Level.WARNING, "OMG.wcharBadGiopVersionReturned",
2632 parameters, OMGSystemException.class, exc ) ;
2633 }
2634
2635 return exc ;
2636 }
2637
2638 public MARSHAL wcharBadGiopVersionReturned( CompletionStatus cs ) {
2639 return wcharBadGiopVersionReturned( cs, null ) ;
2640 }
2641
2642 public MARSHAL wcharBadGiopVersionReturned( Throwable t ) {
2643 return wcharBadGiopVersionReturned( CompletionStatus.COMPLETED_NO, t ) ;
2644 }
2645
2646 public MARSHAL wcharBadGiopVersionReturned( ) {
2647 return wcharBadGiopVersionReturned( CompletionStatus.COMPLETED_NO, null ) ;
2648 }
2649
2650 public static final int UNSUPPORTED_FORMAT_VERSION = OMGVMCID.value + 7 ;
2651
2652 public MARSHAL unsupportedFormatVersion( CompletionStatus cs, Throwable t ) {
2653 MARSHAL exc = new MARSHAL ( UNSUPPORTED_FORMAT_VERSION, cs ) ;
2654 if (t != null)
2655 exc.initCause( t ) ;
2656
2657 if (logger.isLoggable( Level.WARNING )) {
2658 Object [] parameters = null ;
2659 doLog( Level.WARNING, "OMG.unsupportedFormatVersion",
2660 parameters, OMGSystemException.class, exc ) ;
2661 }
2662
2663 return exc ;
2664 }
2665
2666 public MARSHAL unsupportedFormatVersion( CompletionStatus cs ) {
2667 return unsupportedFormatVersion( cs, null ) ;
2668 }
2669
2670 public MARSHAL unsupportedFormatVersion( Throwable t ) {
2671 return unsupportedFormatVersion( CompletionStatus.COMPLETED_NO, t ) ;
2672 }
2673
2674 public MARSHAL unsupportedFormatVersion( ) {
2675 return unsupportedFormatVersion( CompletionStatus.COMPLETED_NO, null ) ;
2676 }
2677
2678 public static final int RMIIIOP_OPTIONAL_DATA_INCOMPATIBLE1 = OMGVMCID.value + 8 ;
2679
2680 public MARSHAL rmiiiopOptionalDataIncompatible1( CompletionStatus cs, Throwable t ) {
2681 MARSHAL exc = new MARSHAL ( RMIIIOP_OPTIONAL_DATA_INCOMPATIBLE1, cs ) ;
2682 if (t != null)
2683 exc.initCause( t ) ;
2684
2685 if (logger.isLoggable( Level.WARNING )) {
2686 Object [] parameters = null ;
2687 doLog( Level.WARNING, "OMG.rmiiiopOptionalDataIncompatible1",
2688 parameters, OMGSystemException.class, exc ) ;
2689 }
2690
2691 return exc ;
2692 }
2693
2694 public MARSHAL rmiiiopOptionalDataIncompatible1( CompletionStatus cs ) {
2695 return rmiiiopOptionalDataIncompatible1( cs, null ) ;
2696 }
2697
2698 public MARSHAL rmiiiopOptionalDataIncompatible1( Throwable t ) {
2699 return rmiiiopOptionalDataIncompatible1( CompletionStatus.COMPLETED_NO, t ) ;
2700 }
2701
2702 public MARSHAL rmiiiopOptionalDataIncompatible1( ) {
2703 return rmiiiopOptionalDataIncompatible1( CompletionStatus.COMPLETED_NO, null ) ;
2704 }
2705
2706 public static final int RMIIIOP_OPTIONAL_DATA_INCOMPATIBLE2 = OMGVMCID.value + 8 ;
2707
2708 public MARSHAL rmiiiopOptionalDataIncompatible2( CompletionStatus cs, Throwable t ) {
2709 MARSHAL exc = new MARSHAL ( RMIIIOP_OPTIONAL_DATA_INCOMPATIBLE2, cs ) ;
2710 if (t != null)
2711 exc.initCause( t ) ;
2712
2713 if (logger.isLoggable( Level.WARNING )) {
2714 Object [] parameters = null ;
2715 doLog( Level.WARNING, "OMG.rmiiiopOptionalDataIncompatible2",
2716 parameters, OMGSystemException.class, exc ) ;
2717 }
2718
2719 return exc ;
2720 }
2721
2722 public MARSHAL rmiiiopOptionalDataIncompatible2( CompletionStatus cs ) {
2723 return rmiiiopOptionalDataIncompatible2( cs, null ) ;
2724 }
2725
2726 public MARSHAL rmiiiopOptionalDataIncompatible2( Throwable t ) {
2727 return rmiiiopOptionalDataIncompatible2( CompletionStatus.COMPLETED_NO, t ) ;
2728 }
2729
2730 public MARSHAL rmiiiopOptionalDataIncompatible2( ) {
2731 return rmiiiopOptionalDataIncompatible2( CompletionStatus.COMPLETED_NO, null ) ;
2732 }
2733
2734 public static final int RMIIIOP_OPTIONAL_DATA_INCOMPATIBLE3 = OMGVMCID.value + 8 ;
2735
2736 public MARSHAL rmiiiopOptionalDataIncompatible3( CompletionStatus cs, Throwable t ) {
2737 MARSHAL exc = new MARSHAL ( RMIIIOP_OPTIONAL_DATA_INCOMPATIBLE3, cs ) ;
2738 if (t != null)
2739 exc.initCause( t ) ;
2740
2741 if (logger.isLoggable( Level.FINE )) {
2742 Object [] parameters = null ;
2743 doLog( Level.FINE, "OMG.rmiiiopOptionalDataIncompatible3",
2744 parameters, OMGSystemException.class, exc ) ;
2745 }
2746
2747 return exc ;
2748 }
2749
2750 public MARSHAL rmiiiopOptionalDataIncompatible3( CompletionStatus cs ) {
2751 return rmiiiopOptionalDataIncompatible3( cs, null ) ;
2752 }
2753
2754 public MARSHAL rmiiiopOptionalDataIncompatible3( Throwable t ) {
2755 return rmiiiopOptionalDataIncompatible3( CompletionStatus.COMPLETED_NO, t ) ;
2756 }
2757
2758 public MARSHAL rmiiiopOptionalDataIncompatible3( ) {
2759 return rmiiiopOptionalDataIncompatible3( CompletionStatus.COMPLETED_NO, null ) ;
2760 }
2761
2762
2766 public static final int MISSING_LOCAL_VALUE_IMPL = OMGVMCID.value + 1 ;
2767
2768 public NO_IMPLEMENT missingLocalValueImpl( CompletionStatus cs, Throwable t ) {
2769 NO_IMPLEMENT exc = new NO_IMPLEMENT ( MISSING_LOCAL_VALUE_IMPL, cs ) ;
2770 if (t != null)
2771 exc.initCause( t ) ;
2772
2773 if (logger.isLoggable( Level.WARNING )) {
2774 Object [] parameters = null ;
2775 doLog( Level.WARNING, "OMG.missingLocalValueImpl",
2776 parameters, OMGSystemException.class, exc ) ;
2777 }
2778
2779 return exc ;
2780 }
2781
2782 public NO_IMPLEMENT missingLocalValueImpl( CompletionStatus cs ) {
2783 return missingLocalValueImpl( cs, null ) ;
2784 }
2785
2786 public NO_IMPLEMENT missingLocalValueImpl( Throwable t ) {
2787 return missingLocalValueImpl( CompletionStatus.COMPLETED_NO, t ) ;
2788 }
2789
2790 public NO_IMPLEMENT missingLocalValueImpl( ) {
2791 return missingLocalValueImpl( CompletionStatus.COMPLETED_NO, null ) ;
2792 }
2793
2794 public static final int INCOMPATIBLE_VALUE_IMPL = OMGVMCID.value + 2 ;
2795
2796 public NO_IMPLEMENT incompatibleValueImpl( CompletionStatus cs, Throwable t ) {
2797 NO_IMPLEMENT exc = new NO_IMPLEMENT ( INCOMPATIBLE_VALUE_IMPL, cs ) ;
2798 if (t != null)
2799 exc.initCause( t ) ;
2800
2801 if (logger.isLoggable( Level.WARNING )) {
2802 Object [] parameters = null ;
2803 doLog( Level.WARNING, "OMG.incompatibleValueImpl",
2804 parameters, OMGSystemException.class, exc ) ;
2805 }
2806
2807 return exc ;
2808 }
2809
2810 public NO_IMPLEMENT incompatibleValueImpl( CompletionStatus cs ) {
2811 return incompatibleValueImpl( cs, null ) ;
2812 }
2813
2814 public NO_IMPLEMENT incompatibleValueImpl( Throwable t ) {
2815 return incompatibleValueImpl( CompletionStatus.COMPLETED_NO, t ) ;
2816 }
2817
2818 public NO_IMPLEMENT incompatibleValueImpl( ) {
2819 return incompatibleValueImpl( CompletionStatus.COMPLETED_NO, null ) ;
2820 }
2821
2822 public static final int NO_USABLE_PROFILE_2 = OMGVMCID.value + 3 ;
2823
2824 public NO_IMPLEMENT noUsableProfile2( CompletionStatus cs, Throwable t ) {
2825 NO_IMPLEMENT exc = new NO_IMPLEMENT ( NO_USABLE_PROFILE_2, cs ) ;
2826 if (t != null)
2827 exc.initCause( t ) ;
2828
2829 if (logger.isLoggable( Level.WARNING )) {
2830 Object [] parameters = null ;
2831 doLog( Level.WARNING, "OMG.noUsableProfile2",
2832 parameters, OMGSystemException.class, exc ) ;
2833 }
2834
2835 return exc ;
2836 }
2837
2838 public NO_IMPLEMENT noUsableProfile2( CompletionStatus cs ) {
2839 return noUsableProfile2( cs, null ) ;
2840 }
2841
2842 public NO_IMPLEMENT noUsableProfile2( Throwable t ) {
2843 return noUsableProfile2( CompletionStatus.COMPLETED_NO, t ) ;
2844 }
2845
2846 public NO_IMPLEMENT noUsableProfile2( ) {
2847 return noUsableProfile2( CompletionStatus.COMPLETED_NO, null ) ;
2848 }
2849
2850 public static final int DII_LOCAL_OBJECT = OMGVMCID.value + 4 ;
2851
2852 public NO_IMPLEMENT diiLocalObject( CompletionStatus cs, Throwable t ) {
2853 NO_IMPLEMENT exc = new NO_IMPLEMENT ( DII_LOCAL_OBJECT, cs ) ;
2854 if (t != null)
2855 exc.initCause( t ) ;
2856
2857 if (logger.isLoggable( Level.WARNING )) {
2858 Object [] parameters = null ;
2859 doLog( Level.WARNING, "OMG.diiLocalObject",
2860 parameters, OMGSystemException.class, exc ) ;
2861 }
2862
2863 return exc ;
2864 }
2865
2866 public NO_IMPLEMENT diiLocalObject( CompletionStatus cs ) {
2867 return diiLocalObject( cs, null ) ;
2868 }
2869
2870 public NO_IMPLEMENT diiLocalObject( Throwable t ) {
2871 return diiLocalObject( CompletionStatus.COMPLETED_NO, t ) ;
2872 }
2873
2874 public NO_IMPLEMENT diiLocalObject( ) {
2875 return diiLocalObject( CompletionStatus.COMPLETED_NO, null ) ;
2876 }
2877
2878 public static final int BIO_RESET = OMGVMCID.value + 5 ;
2879
2880 public NO_IMPLEMENT bioReset( CompletionStatus cs, Throwable t ) {
2881 NO_IMPLEMENT exc = new NO_IMPLEMENT ( BIO_RESET, cs ) ;
2882 if (t != null)
2883 exc.initCause( t ) ;
2884
2885 if (logger.isLoggable( Level.WARNING )) {
2886 Object [] parameters = null ;
2887 doLog( Level.WARNING, "OMG.bioReset",
2888 parameters, OMGSystemException.class, exc ) ;
2889 }
2890
2891 return exc ;
2892 }
2893
2894 public NO_IMPLEMENT bioReset( CompletionStatus cs ) {
2895 return bioReset( cs, null ) ;
2896 }
2897
2898 public NO_IMPLEMENT bioReset( Throwable t ) {
2899 return bioReset( CompletionStatus.COMPLETED_NO, t ) ;
2900 }
2901
2902 public NO_IMPLEMENT bioReset( ) {
2903 return bioReset( CompletionStatus.COMPLETED_NO, null ) ;
2904 }
2905
2906 public static final int BIO_META_NOT_AVAILABLE = OMGVMCID.value + 6 ;
2907
2908 public NO_IMPLEMENT bioMetaNotAvailable( CompletionStatus cs, Throwable t ) {
2909 NO_IMPLEMENT exc = new NO_IMPLEMENT ( BIO_META_NOT_AVAILABLE, cs ) ;
2910 if (t != null)
2911 exc.initCause( t ) ;
2912
2913 if (logger.isLoggable( Level.WARNING )) {
2914 Object [] parameters = null ;
2915 doLog( Level.WARNING, "OMG.bioMetaNotAvailable",
2916 parameters, OMGSystemException.class, exc ) ;
2917 }
2918
2919 return exc ;
2920 }
2921
2922 public NO_IMPLEMENT bioMetaNotAvailable( CompletionStatus cs ) {
2923 return bioMetaNotAvailable( cs, null ) ;
2924 }
2925
2926 public NO_IMPLEMENT bioMetaNotAvailable( Throwable t ) {
2927 return bioMetaNotAvailable( CompletionStatus.COMPLETED_NO, t ) ;
2928 }
2929
2930 public NO_IMPLEMENT bioMetaNotAvailable( ) {
2931 return bioMetaNotAvailable( CompletionStatus.COMPLETED_NO, null ) ;
2932 }
2933
2934 public static final int BIO_GENOMIC_NO_ITERATOR = OMGVMCID.value + 7 ;
2935
2936 public NO_IMPLEMENT bioGenomicNoIterator( CompletionStatus cs, Throwable t ) {
2937 NO_IMPLEMENT exc = new NO_IMPLEMENT ( BIO_GENOMIC_NO_ITERATOR, cs ) ;
2938 if (t != null)
2939 exc.initCause( t ) ;
2940
2941 if (logger.isLoggable( Level.WARNING )) {
2942 Object [] parameters = null ;
2943 doLog( Level.WARNING, "OMG.bioGenomicNoIterator",
2944 parameters, OMGSystemException.class, exc ) ;
2945 }
2946
2947 return exc ;
2948 }
2949
2950 public NO_IMPLEMENT bioGenomicNoIterator( CompletionStatus cs ) {
2951 return bioGenomicNoIterator( cs, null ) ;
2952 }
2953
2954 public NO_IMPLEMENT bioGenomicNoIterator( Throwable t ) {
2955 return bioGenomicNoIterator( CompletionStatus.COMPLETED_NO, t ) ;
2956 }
2957
2958 public NO_IMPLEMENT bioGenomicNoIterator( ) {
2959 return bioGenomicNoIterator( CompletionStatus.COMPLETED_NO, null ) ;
2960 }
2961
2962
2966 public static final int PI_OPERATION_NOT_SUPPORTED1 = OMGVMCID.value + 1 ;
2967
2968 public NO_RESOURCES piOperationNotSupported1( CompletionStatus cs, Throwable t ) {
2969 NO_RESOURCES exc = new NO_RESOURCES ( PI_OPERATION_NOT_SUPPORTED1, cs ) ;
2970 if (t != null)
2971 exc.initCause( t ) ;
2972
2973 if (logger.isLoggable( Level.FINE )) {
2974 Object [] parameters = null ;
2975 doLog( Level.FINE, "OMG.piOperationNotSupported1",
2976 parameters, OMGSystemException.class, exc ) ;
2977 }
2978
2979 return exc ;
2980 }
2981
2982 public NO_RESOURCES piOperationNotSupported1( CompletionStatus cs ) {
2983 return piOperationNotSupported1( cs, null ) ;
2984 }
2985
2986 public NO_RESOURCES piOperationNotSupported1( Throwable t ) {
2987 return piOperationNotSupported1( CompletionStatus.COMPLETED_NO, t ) ;
2988 }
2989
2990 public NO_RESOURCES piOperationNotSupported1( ) {
2991 return piOperationNotSupported1( CompletionStatus.COMPLETED_NO, null ) ;
2992 }
2993
2994 public static final int PI_OPERATION_NOT_SUPPORTED2 = OMGVMCID.value + 1 ;
2995
2996 public NO_RESOURCES piOperationNotSupported2( CompletionStatus cs, Throwable t ) {
2997 NO_RESOURCES exc = new NO_RESOURCES ( PI_OPERATION_NOT_SUPPORTED2, cs ) ;
2998 if (t != null)
2999 exc.initCause( t ) ;
3000
3001 if (logger.isLoggable( Level.FINE )) {
3002 Object [] parameters = null ;
3003 doLog( Level.FINE, "OMG.piOperationNotSupported2",
3004 parameters, OMGSystemException.class, exc ) ;
3005 }
3006
3007 return exc ;
3008 }
3009
3010 public NO_RESOURCES piOperationNotSupported2( CompletionStatus cs ) {
3011 return piOperationNotSupported2( cs, null ) ;
3012 }
3013
3014 public NO_RESOURCES piOperationNotSupported2( Throwable t ) {
3015 return piOperationNotSupported2( CompletionStatus.COMPLETED_NO, t ) ;
3016 }
3017
3018 public NO_RESOURCES piOperationNotSupported2( ) {
3019 return piOperationNotSupported2( CompletionStatus.COMPLETED_NO, null ) ;
3020 }
3021
3022 public static final int PI_OPERATION_NOT_SUPPORTED3 = OMGVMCID.value + 1 ;
3023
3024 public NO_RESOURCES piOperationNotSupported3( CompletionStatus cs, Throwable t ) {
3025 NO_RESOURCES exc = new NO_RESOURCES ( PI_OPERATION_NOT_SUPPORTED3, cs ) ;
3026 if (t != null)
3027 exc.initCause( t ) ;
3028
3029 if (logger.isLoggable( Level.FINE )) {
3030 Object [] parameters = null ;
3031 doLog( Level.FINE, "OMG.piOperationNotSupported3",
3032 parameters, OMGSystemException.class, exc ) ;
3033 }
3034
3035 return exc ;
3036 }
3037
3038 public NO_RESOURCES piOperationNotSupported3( CompletionStatus cs ) {
3039 return piOperationNotSupported3( cs, null ) ;
3040 }
3041
3042 public NO_RESOURCES piOperationNotSupported3( Throwable t ) {
3043 return piOperationNotSupported3( CompletionStatus.COMPLETED_NO, t ) ;
3044 }
3045
3046 public NO_RESOURCES piOperationNotSupported3( ) {
3047 return piOperationNotSupported3( CompletionStatus.COMPLETED_NO, null ) ;
3048 }
3049
3050 public static final int PI_OPERATION_NOT_SUPPORTED4 = OMGVMCID.value + 1 ;
3051
3052 public NO_RESOURCES piOperationNotSupported4( CompletionStatus cs, Throwable t ) {
3053 NO_RESOURCES exc = new NO_RESOURCES ( PI_OPERATION_NOT_SUPPORTED4, cs ) ;
3054 if (t != null)
3055 exc.initCause( t ) ;
3056
3057 if (logger.isLoggable( Level.FINE )) {
3058 Object [] parameters = null ;
3059 doLog( Level.FINE, "OMG.piOperationNotSupported4",
3060 parameters, OMGSystemException.class, exc ) ;
3061 }
3062
3063 return exc ;
3064 }
3065
3066 public NO_RESOURCES piOperationNotSupported4( CompletionStatus cs ) {
3067 return piOperationNotSupported4( cs, null ) ;
3068 }
3069
3070 public NO_RESOURCES piOperationNotSupported4( Throwable t ) {
3071 return piOperationNotSupported4( CompletionStatus.COMPLETED_NO, t ) ;
3072 }
3073
3074 public NO_RESOURCES piOperationNotSupported4( ) {
3075 return piOperationNotSupported4( CompletionStatus.COMPLETED_NO, null ) ;
3076 }
3077
3078 public static final int PI_OPERATION_NOT_SUPPORTED5 = OMGVMCID.value + 1 ;
3079
3080 public NO_RESOURCES piOperationNotSupported5( CompletionStatus cs, Throwable t ) {
3081 NO_RESOURCES exc = new NO_RESOURCES ( PI_OPERATION_NOT_SUPPORTED5, cs ) ;
3082 if (t != null)
3083 exc.initCause( t ) ;
3084
3085 if (logger.isLoggable( Level.FINE )) {
3086 Object [] parameters = null ;
3087 doLog( Level.FINE, "OMG.piOperationNotSupported5",
3088 parameters, OMGSystemException.class, exc ) ;
3089 }
3090
3091 return exc ;
3092 }
3093
3094 public NO_RESOURCES piOperationNotSupported5( CompletionStatus cs ) {
3095 return piOperationNotSupported5( cs, null ) ;
3096 }
3097
3098 public NO_RESOURCES piOperationNotSupported5( Throwable t ) {
3099 return piOperationNotSupported5( CompletionStatus.COMPLETED_NO, t ) ;
3100 }
3101
3102 public NO_RESOURCES piOperationNotSupported5( ) {
3103 return piOperationNotSupported5( CompletionStatus.COMPLETED_NO, null ) ;
3104 }
3105
3106 public static final int PI_OPERATION_NOT_SUPPORTED6 = OMGVMCID.value + 1 ;
3107
3108 public NO_RESOURCES piOperationNotSupported6( CompletionStatus cs, Throwable t ) {
3109 NO_RESOURCES exc = new NO_RESOURCES ( PI_OPERATION_NOT_SUPPORTED6, cs ) ;
3110 if (t != null)
3111 exc.initCause( t ) ;
3112
3113 if (logger.isLoggable( Level.FINE )) {
3114 Object [] parameters = null ;
3115 doLog( Level.FINE, "OMG.piOperationNotSupported6",
3116 parameters, OMGSystemException.class, exc ) ;
3117 }
3118
3119 return exc ;
3120 }
3121
3122 public NO_RESOURCES piOperationNotSupported6( CompletionStatus cs ) {
3123 return piOperationNotSupported6( cs, null ) ;
3124 }
3125
3126 public NO_RESOURCES piOperationNotSupported6( Throwable t ) {
3127 return piOperationNotSupported6( CompletionStatus.COMPLETED_NO, t ) ;
3128 }
3129
3130 public NO_RESOURCES piOperationNotSupported6( ) {
3131 return piOperationNotSupported6( CompletionStatus.COMPLETED_NO, null ) ;
3132 }
3133
3134 public static final int PI_OPERATION_NOT_SUPPORTED7 = OMGVMCID.value + 1 ;
3135
3136 public NO_RESOURCES piOperationNotSupported7( CompletionStatus cs, Throwable t ) {
3137 NO_RESOURCES exc = new NO_RESOURCES ( PI_OPERATION_NOT_SUPPORTED7, cs ) ;
3138 if (t != null)
3139 exc.initCause( t ) ;
3140
3141 if (logger.isLoggable( Level.FINE )) {
3142 Object [] parameters = null ;
3143 doLog( Level.FINE, "OMG.piOperationNotSupported7",
3144 parameters, OMGSystemException.class, exc ) ;
3145 }
3146
3147 return exc ;
3148 }
3149
3150 public NO_RESOURCES piOperationNotSupported7( CompletionStatus cs ) {
3151 return piOperationNotSupported7( cs, null ) ;
3152 }
3153
3154 public NO_RESOURCES piOperationNotSupported7( Throwable t ) {
3155 return piOperationNotSupported7( CompletionStatus.COMPLETED_NO, t ) ;
3156 }
3157
3158 public NO_RESOURCES piOperationNotSupported7( ) {
3159 return piOperationNotSupported7( CompletionStatus.COMPLETED_NO, null ) ;
3160 }
3161
3162 public static final int PI_OPERATION_NOT_SUPPORTED8 = OMGVMCID.value + 1 ;
3163
3164 public NO_RESOURCES piOperationNotSupported8( CompletionStatus cs, Throwable t ) {
3165 NO_RESOURCES exc = new NO_RESOURCES ( PI_OPERATION_NOT_SUPPORTED8, cs ) ;
3166 if (t != null)
3167 exc.initCause( t ) ;
3168
3169 if (logger.isLoggable( Level.FINE )) {
3170 Object [] parameters = null ;
3171 doLog( Level.FINE, "OMG.piOperationNotSupported8",
3172 parameters, OMGSystemException.class, exc ) ;
3173 }
3174
3175 return exc ;
3176 }
3177
3178 public NO_RESOURCES piOperationNotSupported8( CompletionStatus cs ) {
3179 return piOperationNotSupported8( cs, null ) ;
3180 }
3181
3182 public NO_RESOURCES piOperationNotSupported8( Throwable t ) {
3183 return piOperationNotSupported8( CompletionStatus.COMPLETED_NO, t ) ;
3184 }
3185
3186 public NO_RESOURCES piOperationNotSupported8( ) {
3187 return piOperationNotSupported8( CompletionStatus.COMPLETED_NO, null ) ;
3188 }
3189
3190 public static final int NO_CONNECTION_PRIORITY = OMGVMCID.value + 2 ;
3191
3192 public NO_RESOURCES noConnectionPriority( CompletionStatus cs, Throwable t ) {
3193 NO_RESOURCES exc = new NO_RESOURCES ( NO_CONNECTION_PRIORITY, cs ) ;
3194 if (t != null)
3195 exc.initCause( t ) ;
3196
3197 if (logger.isLoggable( Level.WARNING )) {
3198 Object [] parameters = null ;
3199 doLog( Level.WARNING, "OMG.noConnectionPriority",
3200 parameters, OMGSystemException.class, exc ) ;
3201 }
3202
3203 return exc ;
3204 }
3205
3206 public NO_RESOURCES noConnectionPriority( CompletionStatus cs ) {
3207 return noConnectionPriority( cs, null ) ;
3208 }
3209
3210 public NO_RESOURCES noConnectionPriority( Throwable t ) {
3211 return noConnectionPriority( CompletionStatus.COMPLETED_NO, t ) ;
3212 }
3213
3214 public NO_RESOURCES noConnectionPriority( ) {
3215 return noConnectionPriority( CompletionStatus.COMPLETED_NO, null ) ;
3216 }
3217
3218
3222 public static final int XA_RB = OMGVMCID.value + 1 ;
3223
3224 public TRANSACTION_ROLLEDBACK xaRb( CompletionStatus cs, Throwable t ) {
3225 TRANSACTION_ROLLEDBACK exc = new TRANSACTION_ROLLEDBACK ( XA_RB, cs ) ;
3226 if (t != null)
3227 exc.initCause( t ) ;
3228
3229 if (logger.isLoggable( Level.WARNING )) {
3230 Object [] parameters = null ;
3231 doLog( Level.WARNING, "OMG.xaRb",
3232 parameters, OMGSystemException.class, exc ) ;
3233 }
3234
3235 return exc ;
3236 }
3237
3238 public TRANSACTION_ROLLEDBACK xaRb( CompletionStatus cs ) {
3239 return xaRb( cs, null ) ;
3240 }
3241
3242 public TRANSACTION_ROLLEDBACK xaRb( Throwable t ) {
3243 return xaRb( CompletionStatus.COMPLETED_NO, t ) ;
3244 }
3245
3246 public TRANSACTION_ROLLEDBACK xaRb( ) {
3247 return xaRb( CompletionStatus.COMPLETED_NO, null ) ;
3248 }
3249
3250 public static final int XA_NOTA = OMGVMCID.value + 2 ;
3251
3252 public TRANSACTION_ROLLEDBACK xaNota( CompletionStatus cs, Throwable t ) {
3253 TRANSACTION_ROLLEDBACK exc = new TRANSACTION_ROLLEDBACK ( XA_NOTA, cs ) ;
3254 if (t != null)
3255 exc.initCause( t ) ;
3256
3257 if (logger.isLoggable( Level.WARNING )) {
3258 Object [] parameters = null ;
3259 doLog( Level.WARNING, "OMG.xaNota",
3260 parameters, OMGSystemException.class, exc ) ;
3261 }
3262
3263 return exc ;
3264 }
3265
3266 public TRANSACTION_ROLLEDBACK xaNota( CompletionStatus cs ) {
3267 return xaNota( cs, null ) ;
3268 }
3269
3270 public TRANSACTION_ROLLEDBACK xaNota( Throwable t ) {
3271 return xaNota( CompletionStatus.COMPLETED_NO, t ) ;
3272 }
3273
3274 public TRANSACTION_ROLLEDBACK xaNota( ) {
3275 return xaNota( CompletionStatus.COMPLETED_NO, null ) ;
3276 }
3277
3278 public static final int XA_END_TRUE_ROLLBACK_DEFERRED = OMGVMCID.value + 3 ;
3279
3280 public TRANSACTION_ROLLEDBACK xaEndTrueRollbackDeferred( CompletionStatus cs, Throwable t ) {
3281 TRANSACTION_ROLLEDBACK exc = new TRANSACTION_ROLLEDBACK ( XA_END_TRUE_ROLLBACK_DEFERRED, cs ) ;
3282 if (t != null)
3283 exc.initCause( t ) ;
3284
3285 if (logger.isLoggable( Level.WARNING )) {
3286 Object [] parameters = null ;
3287 doLog( Level.WARNING, "OMG.xaEndTrueRollbackDeferred",
3288 parameters, OMGSystemException.class, exc ) ;
3289 }
3290
3291 return exc ;
3292 }
3293
3294 public TRANSACTION_ROLLEDBACK xaEndTrueRollbackDeferred( CompletionStatus cs ) {
3295 return xaEndTrueRollbackDeferred( cs, null ) ;
3296 }
3297
3298 public TRANSACTION_ROLLEDBACK xaEndTrueRollbackDeferred( Throwable t ) {
3299 return xaEndTrueRollbackDeferred( CompletionStatus.COMPLETED_NO, t ) ;
3300 }
3301
3302 public TRANSACTION_ROLLEDBACK xaEndTrueRollbackDeferred( ) {
3303 return xaEndTrueRollbackDeferred( CompletionStatus.COMPLETED_NO, null ) ;
3304 }
3305
3306
3310 public static final int POA_REQUEST_DISCARD = OMGVMCID.value + 1 ;
3311
3312 public TRANSIENT poaRequestDiscard( CompletionStatus cs, Throwable t ) {
3313 TRANSIENT exc = new TRANSIENT ( POA_REQUEST_DISCARD, cs ) ;
3314 if (t != null)
3315 exc.initCause( t ) ;
3316
3317 if (logger.isLoggable( Level.WARNING )) {
3318 Object [] parameters = null ;
3319 doLog( Level.WARNING, "OMG.poaRequestDiscard",
3320 parameters, OMGSystemException.class, exc ) ;
3321 }
3322
3323 return exc ;
3324 }
3325
3326 public TRANSIENT poaRequestDiscard( CompletionStatus cs ) {
3327 return poaRequestDiscard( cs, null ) ;
3328 }
3329
3330 public TRANSIENT poaRequestDiscard( Throwable t ) {
3331 return poaRequestDiscard( CompletionStatus.COMPLETED_NO, t ) ;
3332 }
3333
3334 public TRANSIENT poaRequestDiscard( ) {
3335 return poaRequestDiscard( CompletionStatus.COMPLETED_NO, null ) ;
3336 }
3337
3338 public static final int NO_USABLE_PROFILE_3 = OMGVMCID.value + 2 ;
3339
3340 public TRANSIENT noUsableProfile3( CompletionStatus cs, Throwable t ) {
3341 TRANSIENT exc = new TRANSIENT ( NO_USABLE_PROFILE_3, cs ) ;
3342 if (t != null)
3343 exc.initCause( t ) ;
3344
3345 if (logger.isLoggable( Level.WARNING )) {
3346 Object [] parameters = null ;
3347 doLog( Level.WARNING, "OMG.noUsableProfile3",
3348 parameters, OMGSystemException.class, exc ) ;
3349 }
3350
3351 return exc ;
3352 }
3353
3354 public TRANSIENT noUsableProfile3( CompletionStatus cs ) {
3355 return noUsableProfile3( cs, null ) ;
3356 }
3357
3358 public TRANSIENT noUsableProfile3( Throwable t ) {
3359 return noUsableProfile3( CompletionStatus.COMPLETED_NO, t ) ;
3360 }
3361
3362 public TRANSIENT noUsableProfile3( ) {
3363 return noUsableProfile3( CompletionStatus.COMPLETED_NO, null ) ;
3364 }
3365
3366 public static final int REQUEST_CANCELLED = OMGVMCID.value + 3 ;
3367
3368 public TRANSIENT requestCancelled( CompletionStatus cs, Throwable t ) {
3369 TRANSIENT exc = new TRANSIENT ( REQUEST_CANCELLED, cs ) ;
3370 if (t != null)
3371 exc.initCause( t ) ;
3372
3373 if (logger.isLoggable( Level.WARNING )) {
3374 Object [] parameters = null ;
3375 doLog( Level.WARNING, "OMG.requestCancelled",
3376 parameters, OMGSystemException.class, exc ) ;
3377 }
3378
3379 return exc ;
3380 }
3381
3382 public TRANSIENT requestCancelled( CompletionStatus cs ) {
3383 return requestCancelled( cs, null ) ;
3384 }
3385
3386 public TRANSIENT requestCancelled( Throwable t ) {
3387 return requestCancelled( CompletionStatus.COMPLETED_NO, t ) ;
3388 }
3389
3390 public TRANSIENT requestCancelled( ) {
3391 return requestCancelled( CompletionStatus.COMPLETED_NO, null ) ;
3392 }
3393
3394 public static final int POA_DESTROYED = OMGVMCID.value + 4 ;
3395
3396 public TRANSIENT poaDestroyed( CompletionStatus cs, Throwable t ) {
3397 TRANSIENT exc = new TRANSIENT ( POA_DESTROYED, cs ) ;
3398 if (t != null)
3399 exc.initCause( t ) ;
3400
3401 if (logger.isLoggable( Level.WARNING )) {
3402 Object [] parameters = null ;
3403 doLog( Level.WARNING, "OMG.poaDestroyed",
3404 parameters, OMGSystemException.class, exc ) ;
3405 }
3406
3407 return exc ;
3408 }
3409
3410 public TRANSIENT poaDestroyed( CompletionStatus cs ) {
3411 return poaDestroyed( cs, null ) ;
3412 }
3413
3414 public TRANSIENT poaDestroyed( Throwable t ) {
3415 return poaDestroyed( CompletionStatus.COMPLETED_NO, t ) ;
3416 }
3417
3418 public TRANSIENT poaDestroyed( ) {
3419 return poaDestroyed( CompletionStatus.COMPLETED_NO, null ) ;
3420 }
3421
3422
3426 public static final int UNREGISTERED_VALUE_AS_OBJREF = OMGVMCID.value + 1 ;
3427
3428 public OBJECT_NOT_EXIST unregisteredValueAsObjref( CompletionStatus cs, Throwable t ) {
3429 OBJECT_NOT_EXIST exc = new OBJECT_NOT_EXIST ( UNREGISTERED_VALUE_AS_OBJREF, cs ) ;
3430 if (t != null)
3431 exc.initCause( t ) ;
3432
3433 if (logger.isLoggable( Level.WARNING )) {
3434 Object [] parameters = null ;
3435 doLog( Level.WARNING, "OMG.unregisteredValueAsObjref",
3436 parameters, OMGSystemException.class, exc ) ;
3437 }
3438
3439 return exc ;
3440 }
3441
3442 public OBJECT_NOT_EXIST unregisteredValueAsObjref( CompletionStatus cs ) {
3443 return unregisteredValueAsObjref( cs, null ) ;
3444 }
3445
3446 public OBJECT_NOT_EXIST unregisteredValueAsObjref( Throwable t ) {
3447 return unregisteredValueAsObjref( CompletionStatus.COMPLETED_NO, t ) ;
3448 }
3449
3450 public OBJECT_NOT_EXIST unregisteredValueAsObjref( ) {
3451 return unregisteredValueAsObjref( CompletionStatus.COMPLETED_NO, null ) ;
3452 }
3453
3454 public static final int NO_OBJECT_ADAPTOR = OMGVMCID.value + 2 ;
3455
3456 public OBJECT_NOT_EXIST noObjectAdaptor( CompletionStatus cs, Throwable t ) {
3457 OBJECT_NOT_EXIST exc = new OBJECT_NOT_EXIST ( NO_OBJECT_ADAPTOR, cs ) ;
3458 if (t != null)
3459 exc.initCause( t ) ;
3460
3461 if (logger.isLoggable( Level.FINE )) {
3462 Object [] parameters = null ;
3463 doLog( Level.FINE, "OMG.noObjectAdaptor",
3464 parameters, OMGSystemException.class, exc ) ;
3465 }
3466
3467 return exc ;
3468 }
3469
3470 public OBJECT_NOT_EXIST noObjectAdaptor( CompletionStatus cs ) {
3471 return noObjectAdaptor( cs, null ) ;
3472 }
3473
3474 public OBJECT_NOT_EXIST noObjectAdaptor( Throwable t ) {
3475 return noObjectAdaptor( CompletionStatus.COMPLETED_NO, t ) ;
3476 }
3477
3478 public OBJECT_NOT_EXIST noObjectAdaptor( ) {
3479 return noObjectAdaptor( CompletionStatus.COMPLETED_NO, null ) ;
3480 }
3481
3482 public static final int BIO_NOT_AVAILABLE = OMGVMCID.value + 3 ;
3483
3484 public OBJECT_NOT_EXIST bioNotAvailable( CompletionStatus cs, Throwable t ) {
3485 OBJECT_NOT_EXIST exc = new OBJECT_NOT_EXIST ( BIO_NOT_AVAILABLE, cs ) ;
3486 if (t != null)
3487 exc.initCause( t ) ;
3488
3489 if (logger.isLoggable( Level.WARNING )) {
3490 Object [] parameters = null ;
3491 doLog( Level.WARNING, "OMG.bioNotAvailable",
3492 parameters, OMGSystemException.class, exc ) ;
3493 }
3494
3495 return exc ;
3496 }
3497
3498 public OBJECT_NOT_EXIST bioNotAvailable( CompletionStatus cs ) {
3499 return bioNotAvailable( cs, null ) ;
3500 }
3501
3502 public OBJECT_NOT_EXIST bioNotAvailable( Throwable t ) {
3503 return bioNotAvailable( CompletionStatus.COMPLETED_NO, t ) ;
3504 }
3505
3506 public OBJECT_NOT_EXIST bioNotAvailable( ) {
3507 return bioNotAvailable( CompletionStatus.COMPLETED_NO, null ) ;
3508 }
3509
3510 public static final int OBJECT_ADAPTER_INACTIVE = OMGVMCID.value + 4 ;
3511
3512 public OBJECT_NOT_EXIST objectAdapterInactive( CompletionStatus cs, Throwable t ) {
3513 OBJECT_NOT_EXIST exc = new OBJECT_NOT_EXIST ( OBJECT_ADAPTER_INACTIVE, cs ) ;
3514 if (t != null)
3515 exc.initCause( t ) ;
3516
3517 if (logger.isLoggable( Level.WARNING )) {
3518 Object [] parameters = null ;
3519 doLog( Level.WARNING, "OMG.objectAdapterInactive",
3520 parameters, OMGSystemException.class, exc ) ;
3521 }
3522
3523 return exc ;
3524 }
3525
3526 public OBJECT_NOT_EXIST objectAdapterInactive( CompletionStatus cs ) {
3527 return objectAdapterInactive( cs, null ) ;
3528 }
3529
3530 public OBJECT_NOT_EXIST objectAdapterInactive( Throwable t ) {
3531 return objectAdapterInactive( CompletionStatus.COMPLETED_NO, t ) ;
3532 }
3533
3534 public OBJECT_NOT_EXIST objectAdapterInactive( ) {
3535 return objectAdapterInactive( CompletionStatus.COMPLETED_NO, null ) ;
3536 }
3537
3538
3542 public static final int ADAPTER_ACTIVATOR_EXCEPTION = OMGVMCID.value + 1 ;
3543
3544 public OBJ_ADAPTER adapterActivatorException( CompletionStatus cs, Throwable t, Object arg0, Object arg1) {
3545 OBJ_ADAPTER exc = new OBJ_ADAPTER ( ADAPTER_ACTIVATOR_EXCEPTION, cs ) ;
3546 if (t != null)
3547 exc.initCause( t ) ;
3548
3549 if (logger.isLoggable( Level.WARNING )) {
3550 Object [] parameters = new Object [2] ;
3551 parameters[0] = arg0 ;
3552 parameters[1] = arg1 ;
3553 doLog( Level.WARNING, "OMG.adapterActivatorException",
3554 parameters, OMGSystemException.class, exc ) ;
3555 }
3556
3557 return exc ;
3558 }
3559
3560 public OBJ_ADAPTER adapterActivatorException( CompletionStatus cs, Object arg0, Object arg1) {
3561 return adapterActivatorException( cs, null, arg0, arg1 ) ;
3562 }
3563
3564 public OBJ_ADAPTER adapterActivatorException( Throwable t, Object arg0, Object arg1) {
3565 return adapterActivatorException( CompletionStatus.COMPLETED_NO, t, arg0, arg1 ) ;
3566 }
3567
3568 public OBJ_ADAPTER adapterActivatorException( Object arg0, Object arg1) {
3569 return adapterActivatorException( CompletionStatus.COMPLETED_NO, null, arg0, arg1 ) ;
3570 }
3571
3572 public static final int BAD_SERVANT_TYPE = OMGVMCID.value + 2 ;
3573
3574 public OBJ_ADAPTER badServantType( CompletionStatus cs, Throwable t ) {
3575 OBJ_ADAPTER exc = new OBJ_ADAPTER ( BAD_SERVANT_TYPE, cs ) ;
3576 if (t != null)
3577 exc.initCause( t ) ;
3578
3579 if (logger.isLoggable( Level.WARNING )) {
3580 Object [] parameters = null ;
3581 doLog( Level.WARNING, "OMG.badServantType",
3582 parameters, OMGSystemException.class, exc ) ;
3583 }
3584
3585 return exc ;
3586 }
3587
3588 public OBJ_ADAPTER badServantType( CompletionStatus cs ) {
3589 return badServantType( cs, null ) ;
3590 }
3591
3592 public OBJ_ADAPTER badServantType( Throwable t ) {
3593 return badServantType( CompletionStatus.COMPLETED_NO, t ) ;
3594 }
3595
3596 public OBJ_ADAPTER badServantType( ) {
3597 return badServantType( CompletionStatus.COMPLETED_NO, null ) ;
3598 }
3599
3600 public static final int NO_DEFAULT_SERVANT = OMGVMCID.value + 3 ;
3601
3602 public OBJ_ADAPTER noDefaultServant( CompletionStatus cs, Throwable t ) {
3603 OBJ_ADAPTER exc = new OBJ_ADAPTER ( NO_DEFAULT_SERVANT, cs ) ;
3604 if (t != null)
3605 exc.initCause( t ) ;
3606
3607 if (logger.isLoggable( Level.WARNING )) {
3608 Object [] parameters = null ;
3609 doLog( Level.WARNING, "OMG.noDefaultServant",
3610 parameters, OMGSystemException.class, exc ) ;
3611 }
3612
3613 return exc ;
3614 }
3615
3616 public OBJ_ADAPTER noDefaultServant( CompletionStatus cs ) {
3617 return noDefaultServant( cs, null ) ;
3618 }
3619
3620 public OBJ_ADAPTER noDefaultServant( Throwable t ) {
3621 return noDefaultServant( CompletionStatus.COMPLETED_NO, t ) ;
3622 }
3623
3624 public OBJ_ADAPTER noDefaultServant( ) {
3625 return noDefaultServant( CompletionStatus.COMPLETED_NO, null ) ;
3626 }
3627
3628 public static final int NO_SERVANT_MANAGER = OMGVMCID.value + 4 ;
3629
3630 public OBJ_ADAPTER noServantManager( CompletionStatus cs, Throwable t ) {
3631 OBJ_ADAPTER exc = new OBJ_ADAPTER ( NO_SERVANT_MANAGER, cs ) ;
3632 if (t != null)
3633 exc.initCause( t ) ;
3634
3635 if (logger.isLoggable( Level.WARNING )) {
3636 Object [] parameters = null ;
3637 doLog( Level.WARNING, "OMG.noServantManager",
3638 parameters, OMGSystemException.class, exc ) ;
3639 }
3640
3641 return exc ;
3642 }
3643
3644 public OBJ_ADAPTER noServantManager( CompletionStatus cs ) {
3645 return noServantManager( cs, null ) ;
3646 }
3647
3648 public OBJ_ADAPTER noServantManager( Throwable t ) {
3649 return noServantManager( CompletionStatus.COMPLETED_NO, t ) ;
3650 }
3651
3652 public OBJ_ADAPTER noServantManager( ) {
3653 return noServantManager( CompletionStatus.COMPLETED_NO, null ) ;
3654 }
3655
3656 public static final int BAD_POLICY_INCARNATE = OMGVMCID.value + 5 ;
3657
3658 public OBJ_ADAPTER badPolicyIncarnate( CompletionStatus cs, Throwable t ) {
3659 OBJ_ADAPTER exc = new OBJ_ADAPTER ( BAD_POLICY_INCARNATE, cs ) ;
3660 if (t != null)
3661 exc.initCause( t ) ;
3662
3663 if (logger.isLoggable( Level.WARNING )) {
3664 Object [] parameters = null ;
3665 doLog( Level.WARNING, "OMG.badPolicyIncarnate",
3666 parameters, OMGSystemException.class, exc ) ;
3667 }
3668
3669 return exc ;
3670 }
3671
3672 public OBJ_ADAPTER badPolicyIncarnate( CompletionStatus cs ) {
3673 return badPolicyIncarnate( cs, null ) ;
3674 }
3675
3676 public OBJ_ADAPTER badPolicyIncarnate( Throwable t ) {
3677 return badPolicyIncarnate( CompletionStatus.COMPLETED_NO, t ) ;
3678 }
3679
3680 public OBJ_ADAPTER badPolicyIncarnate( ) {
3681 return badPolicyIncarnate( CompletionStatus.COMPLETED_NO, null ) ;
3682 }
3683
3684 public static final int PI_EXC_COMP_ESTABLISHED = OMGVMCID.value + 6 ;
3685
3686 public OBJ_ADAPTER piExcCompEstablished( CompletionStatus cs, Throwable t ) {
3687 OBJ_ADAPTER exc = new OBJ_ADAPTER ( PI_EXC_COMP_ESTABLISHED, cs ) ;
3688 if (t != null)
3689 exc.initCause( t ) ;
3690
3691 if (logger.isLoggable( Level.WARNING )) {
3692 Object [] parameters = null ;
3693 doLog( Level.WARNING, "OMG.piExcCompEstablished",
3694 parameters, OMGSystemException.class, exc ) ;
3695 }
3696
3697 return exc ;
3698 }
3699
3700 public OBJ_ADAPTER piExcCompEstablished( CompletionStatus cs ) {
3701 return piExcCompEstablished( cs, null ) ;
3702 }
3703
3704 public OBJ_ADAPTER piExcCompEstablished( Throwable t ) {
3705 return piExcCompEstablished( CompletionStatus.COMPLETED_NO, t ) ;
3706 }
3707
3708 public OBJ_ADAPTER piExcCompEstablished( ) {
3709 return piExcCompEstablished( CompletionStatus.COMPLETED_NO, null ) ;
3710 }
3711
3712 public static final int NULL_SERVANT_RETURNED = OMGVMCID.value + 7 ;
3713
3714 public OBJ_ADAPTER nullServantReturned( CompletionStatus cs, Throwable t ) {
3715 OBJ_ADAPTER exc = new OBJ_ADAPTER ( NULL_SERVANT_RETURNED, cs ) ;
3716 if (t != null)
3717 exc.initCause( t ) ;
3718
3719 if (logger.isLoggable( Level.FINE )) {
3720 Object [] parameters = null ;
3721 doLog( Level.FINE, "OMG.nullServantReturned",
3722 parameters, OMGSystemException.class, exc ) ;
3723 }
3724
3725 return exc ;
3726 }
3727
3728 public OBJ_ADAPTER nullServantReturned( CompletionStatus cs ) {
3729 return nullServantReturned( cs, null ) ;
3730 }
3731
3732 public OBJ_ADAPTER nullServantReturned( Throwable t ) {
3733 return nullServantReturned( CompletionStatus.COMPLETED_NO, t ) ;
3734 }
3735
3736 public OBJ_ADAPTER nullServantReturned( ) {
3737 return nullServantReturned( CompletionStatus.COMPLETED_NO, null ) ;
3738 }
3739
3740
3744 public static final int UNKNOWN_USER_EXCEPTION = OMGVMCID.value + 1 ;
3745
3746 public UNKNOWN unknownUserException( CompletionStatus cs, Throwable t ) {
3747 UNKNOWN exc = new UNKNOWN ( UNKNOWN_USER_EXCEPTION, cs ) ;
3748 if (t != null)
3749 exc.initCause( t ) ;
3750
3751 if (logger.isLoggable( Level.FINE )) {
3752 Object [] parameters = null ;
3753 doLog( Level.FINE, "OMG.unknownUserException",
3754 parameters, OMGSystemException.class, exc ) ;
3755 }
3756
3757 return exc ;
3758 }
3759
3760 public UNKNOWN unknownUserException( CompletionStatus cs ) {
3761 return unknownUserException( cs, null ) ;
3762 }
3763
3764 public UNKNOWN unknownUserException( Throwable t ) {
3765 return unknownUserException( CompletionStatus.COMPLETED_NO, t ) ;
3766 }
3767
3768 public UNKNOWN unknownUserException( ) {
3769 return unknownUserException( CompletionStatus.COMPLETED_NO, null ) ;
3770 }
3771
3772 public static final int UNSUPPORTED_SYSTEM_EXCEPTION = OMGVMCID.value + 2 ;
3773
3774 public UNKNOWN unsupportedSystemException( CompletionStatus cs, Throwable t ) {
3775 UNKNOWN exc = new UNKNOWN ( UNSUPPORTED_SYSTEM_EXCEPTION, cs ) ;
3776 if (t != null)
3777 exc.initCause( t ) ;
3778
3779 if (logger.isLoggable( Level.WARNING )) {
3780 Object [] parameters = null ;
3781 doLog( Level.WARNING, "OMG.unsupportedSystemException",
3782 parameters, OMGSystemException.class, exc ) ;
3783 }
3784
3785 return exc ;
3786 }
3787
3788 public UNKNOWN unsupportedSystemException( CompletionStatus cs ) {
3789 return unsupportedSystemException( cs, null ) ;
3790 }
3791
3792 public UNKNOWN unsupportedSystemException( Throwable t ) {
3793 return unsupportedSystemException( CompletionStatus.COMPLETED_NO, t ) ;
3794 }
3795
3796 public UNKNOWN unsupportedSystemException( ) {
3797 return unsupportedSystemException( CompletionStatus.COMPLETED_NO, null ) ;
3798 }
3799
3800 public static final int PI_UNKNOWN_USER_EXCEPTION = OMGVMCID.value + 3 ;
3801
3802 public UNKNOWN piUnknownUserException( CompletionStatus cs, Throwable t ) {
3803 UNKNOWN exc = new UNKNOWN ( PI_UNKNOWN_USER_EXCEPTION, cs ) ;
3804 if (t != null)
3805 exc.initCause( t ) ;
3806
3807 if (logger.isLoggable( Level.WARNING )) {
3808 Object [] parameters = null ;
3809 doLog( Level.WARNING, "OMG.piUnknownUserException",
3810 parameters, OMGSystemException.class, exc ) ;
3811 }
3812
3813 return exc ;
3814 }
3815
3816 public UNKNOWN piUnknownUserException( CompletionStatus cs ) {
3817 return piUnknownUserException( cs, null ) ;
3818 }
3819
3820 public UNKNOWN piUnknownUserException( Throwable t ) {
3821 return piUnknownUserException( CompletionStatus.COMPLETED_NO, t ) ;
3822 }
3823
3824 public UNKNOWN piUnknownUserException( ) {
3825 return piUnknownUserException( CompletionStatus.COMPLETED_NO, null ) ;
3826 }
3827
3828
3829}
3830 |
Popular Tags |
Java API By Example, From Geeks To Geeks.