001 package org.omg.CosTransactions; 002 003 004 /** 005 * Generated from IDL interface "Coordinator". 006 * 007 * @author JacORB IDL compiler V 2.3.0 (JBoss patch 6), 06-Jun-2007 008 * @version generated at Sep 22, 2012 10:57:18 AM 009 */ 010 011 public class _CoordinatorStub 012 extends org.omg.CORBA.portable.ObjectImpl 013 implements org.omg.CosTransactions.Coordinator 014 { 015 private String[] ids = {"IDL:CosTransactions/Coordinator:1.0"}; 016 public String[] _ids() 017 { 018 return ids; 019 } 020 021 public final static java.lang.Class _opsClass = org.omg.CosTransactions.CoordinatorOperations.class; 022 public boolean is_ancestor_transaction(org.omg.CosTransactions.Coordinator tc) 023 { 024 while(true) 025 { 026 if(! this._is_local()) 027 { 028 org.omg.CORBA.portable.InputStream _is = null; 029 try 030 { 031 org.omg.CORBA.portable.OutputStream _os = _request( "is_ancestor_transaction", true); 032 org.omg.CosTransactions.CoordinatorHelper.write(_os,tc); 033 _is = _invoke(_os); 034 boolean _result = _is.read_boolean(); 035 return _result; 036 } 037 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 038 catch( org.omg.CORBA.portable.ApplicationException _ax ) 039 { 040 String _id = _ax.getId(); 041 throw new RuntimeException("Unexpected exception " + _id ); 042 } 043 finally 044 { 045 this._releaseReply(_is); 046 } 047 } 048 else 049 { 050 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "is_ancestor_transaction", _opsClass ); 051 if( _so == null ) 052 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 053 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 054 boolean _result; 055 try 056 { 057 _result = _localServant.is_ancestor_transaction(tc); 058 } 059 finally 060 { 061 _servant_postinvoke(_so); 062 } 063 return _result; 064 } 065 066 } 067 068 } 069 070 public org.omg.CosTransactions.Status get_status() 071 { 072 while(true) 073 { 074 if(! this._is_local()) 075 { 076 org.omg.CORBA.portable.InputStream _is = null; 077 try 078 { 079 org.omg.CORBA.portable.OutputStream _os = _request( "get_status", true); 080 _is = _invoke(_os); 081 org.omg.CosTransactions.Status _result = org.omg.CosTransactions.StatusHelper.read(_is); 082 return _result; 083 } 084 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 085 catch( org.omg.CORBA.portable.ApplicationException _ax ) 086 { 087 String _id = _ax.getId(); 088 throw new RuntimeException("Unexpected exception " + _id ); 089 } 090 finally 091 { 092 this._releaseReply(_is); 093 } 094 } 095 else 096 { 097 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "get_status", _opsClass ); 098 if( _so == null ) 099 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 100 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 101 org.omg.CosTransactions.Status _result; 102 try 103 { 104 _result = _localServant.get_status(); 105 } 106 finally 107 { 108 _servant_postinvoke(_so); 109 } 110 return _result; 111 } 112 113 } 114 115 } 116 117 public boolean is_descendant_transaction(org.omg.CosTransactions.Coordinator tc) 118 { 119 while(true) 120 { 121 if(! this._is_local()) 122 { 123 org.omg.CORBA.portable.InputStream _is = null; 124 try 125 { 126 org.omg.CORBA.portable.OutputStream _os = _request( "is_descendant_transaction", true); 127 org.omg.CosTransactions.CoordinatorHelper.write(_os,tc); 128 _is = _invoke(_os); 129 boolean _result = _is.read_boolean(); 130 return _result; 131 } 132 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 133 catch( org.omg.CORBA.portable.ApplicationException _ax ) 134 { 135 String _id = _ax.getId(); 136 throw new RuntimeException("Unexpected exception " + _id ); 137 } 138 finally 139 { 140 this._releaseReply(_is); 141 } 142 } 143 else 144 { 145 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "is_descendant_transaction", _opsClass ); 146 if( _so == null ) 147 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 148 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 149 boolean _result; 150 try 151 { 152 _result = _localServant.is_descendant_transaction(tc); 153 } 154 finally 155 { 156 _servant_postinvoke(_so); 157 } 158 return _result; 159 } 160 161 } 162 163 } 164 165 public java.lang.String get_transaction_name() 166 { 167 while(true) 168 { 169 if(! this._is_local()) 170 { 171 org.omg.CORBA.portable.InputStream _is = null; 172 try 173 { 174 org.omg.CORBA.portable.OutputStream _os = _request( "get_transaction_name", true); 175 _is = _invoke(_os); 176 java.lang.String _result = _is.read_string(); 177 return _result; 178 } 179 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 180 catch( org.omg.CORBA.portable.ApplicationException _ax ) 181 { 182 String _id = _ax.getId(); 183 throw new RuntimeException("Unexpected exception " + _id ); 184 } 185 finally 186 { 187 this._releaseReply(_is); 188 } 189 } 190 else 191 { 192 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "get_transaction_name", _opsClass ); 193 if( _so == null ) 194 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 195 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 196 java.lang.String _result; 197 try 198 { 199 _result = _localServant.get_transaction_name(); 200 } 201 finally 202 { 203 _servant_postinvoke(_so); 204 } 205 return _result; 206 } 207 208 } 209 210 } 211 212 public org.omg.CosTransactions.Status get_top_level_status() 213 { 214 while(true) 215 { 216 if(! this._is_local()) 217 { 218 org.omg.CORBA.portable.InputStream _is = null; 219 try 220 { 221 org.omg.CORBA.portable.OutputStream _os = _request( "get_top_level_status", true); 222 _is = _invoke(_os); 223 org.omg.CosTransactions.Status _result = org.omg.CosTransactions.StatusHelper.read(_is); 224 return _result; 225 } 226 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 227 catch( org.omg.CORBA.portable.ApplicationException _ax ) 228 { 229 String _id = _ax.getId(); 230 throw new RuntimeException("Unexpected exception " + _id ); 231 } 232 finally 233 { 234 this._releaseReply(_is); 235 } 236 } 237 else 238 { 239 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "get_top_level_status", _opsClass ); 240 if( _so == null ) 241 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 242 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 243 org.omg.CosTransactions.Status _result; 244 try 245 { 246 _result = _localServant.get_top_level_status(); 247 } 248 finally 249 { 250 _servant_postinvoke(_so); 251 } 252 return _result; 253 } 254 255 } 256 257 } 258 259 public org.omg.CosTransactions.Status get_parent_status() 260 { 261 while(true) 262 { 263 if(! this._is_local()) 264 { 265 org.omg.CORBA.portable.InputStream _is = null; 266 try 267 { 268 org.omg.CORBA.portable.OutputStream _os = _request( "get_parent_status", true); 269 _is = _invoke(_os); 270 org.omg.CosTransactions.Status _result = org.omg.CosTransactions.StatusHelper.read(_is); 271 return _result; 272 } 273 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 274 catch( org.omg.CORBA.portable.ApplicationException _ax ) 275 { 276 String _id = _ax.getId(); 277 throw new RuntimeException("Unexpected exception " + _id ); 278 } 279 finally 280 { 281 this._releaseReply(_is); 282 } 283 } 284 else 285 { 286 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "get_parent_status", _opsClass ); 287 if( _so == null ) 288 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 289 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 290 org.omg.CosTransactions.Status _result; 291 try 292 { 293 _result = _localServant.get_parent_status(); 294 } 295 finally 296 { 297 _servant_postinvoke(_so); 298 } 299 return _result; 300 } 301 302 } 303 304 } 305 306 public void rollback_only() throws org.omg.CosTransactions.Inactive 307 { 308 while(true) 309 { 310 if(! this._is_local()) 311 { 312 org.omg.CORBA.portable.InputStream _is = null; 313 try 314 { 315 org.omg.CORBA.portable.OutputStream _os = _request( "rollback_only", true); 316 _is = _invoke(_os); 317 return; 318 } 319 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 320 catch( org.omg.CORBA.portable.ApplicationException _ax ) 321 { 322 String _id = _ax.getId(); 323 if( _id.equals("IDL:CosTransactions/Inactive:1.0")) 324 { 325 throw org.omg.CosTransactions.InactiveHelper.read(_ax.getInputStream()); 326 } 327 throw new RuntimeException("Unexpected exception " + _id ); 328 } 329 finally 330 { 331 this._releaseReply(_is); 332 } 333 } 334 else 335 { 336 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "rollback_only", _opsClass ); 337 if( _so == null ) 338 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 339 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 340 try 341 { 342 _localServant.rollback_only(); 343 } 344 finally 345 { 346 _servant_postinvoke(_so); 347 } 348 return; 349 } 350 351 } 352 353 } 354 355 public boolean is_top_level_transaction() 356 { 357 while(true) 358 { 359 if(! this._is_local()) 360 { 361 org.omg.CORBA.portable.InputStream _is = null; 362 try 363 { 364 org.omg.CORBA.portable.OutputStream _os = _request( "is_top_level_transaction", true); 365 _is = _invoke(_os); 366 boolean _result = _is.read_boolean(); 367 return _result; 368 } 369 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 370 catch( org.omg.CORBA.portable.ApplicationException _ax ) 371 { 372 String _id = _ax.getId(); 373 throw new RuntimeException("Unexpected exception " + _id ); 374 } 375 finally 376 { 377 this._releaseReply(_is); 378 } 379 } 380 else 381 { 382 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "is_top_level_transaction", _opsClass ); 383 if( _so == null ) 384 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 385 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 386 boolean _result; 387 try 388 { 389 _result = _localServant.is_top_level_transaction(); 390 } 391 finally 392 { 393 _servant_postinvoke(_so); 394 } 395 return _result; 396 } 397 398 } 399 400 } 401 402 public org.omg.CosTransactions.Control create_subtransaction() throws org.omg.CosTransactions.SubtransactionsUnavailable,org.omg.CosTransactions.Inactive 403 { 404 while(true) 405 { 406 if(! this._is_local()) 407 { 408 org.omg.CORBA.portable.InputStream _is = null; 409 try 410 { 411 org.omg.CORBA.portable.OutputStream _os = _request( "create_subtransaction", true); 412 _is = _invoke(_os); 413 org.omg.CosTransactions.Control _result = org.omg.CosTransactions.ControlHelper.read(_is); 414 return _result; 415 } 416 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 417 catch( org.omg.CORBA.portable.ApplicationException _ax ) 418 { 419 String _id = _ax.getId(); 420 if( _id.equals("IDL:CosTransactions/SubtransactionsUnavailable:1.0")) 421 { 422 throw org.omg.CosTransactions.SubtransactionsUnavailableHelper.read(_ax.getInputStream()); 423 } 424 else if( _id.equals("IDL:CosTransactions/Inactive:1.0")) 425 { 426 throw org.omg.CosTransactions.InactiveHelper.read(_ax.getInputStream()); 427 } 428 throw new RuntimeException("Unexpected exception " + _id ); 429 } 430 finally 431 { 432 this._releaseReply(_is); 433 } 434 } 435 else 436 { 437 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "create_subtransaction", _opsClass ); 438 if( _so == null ) 439 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 440 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 441 org.omg.CosTransactions.Control _result; 442 try 443 { 444 _result = _localServant.create_subtransaction(); 445 } 446 finally 447 { 448 _servant_postinvoke(_so); 449 } 450 return _result; 451 } 452 453 } 454 455 } 456 457 public org.omg.CosTransactions.PropagationContext get_txcontext() throws org.omg.CosTransactions.Unavailable 458 { 459 while(true) 460 { 461 if(! this._is_local()) 462 { 463 org.omg.CORBA.portable.InputStream _is = null; 464 try 465 { 466 org.omg.CORBA.portable.OutputStream _os = _request( "get_txcontext", true); 467 _is = _invoke(_os); 468 org.omg.CosTransactions.PropagationContext _result = org.omg.CosTransactions.PropagationContextHelper.read(_is); 469 return _result; 470 } 471 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 472 catch( org.omg.CORBA.portable.ApplicationException _ax ) 473 { 474 String _id = _ax.getId(); 475 if( _id.equals("IDL:CosTransactions/Unavailable:1.0")) 476 { 477 throw org.omg.CosTransactions.UnavailableHelper.read(_ax.getInputStream()); 478 } 479 throw new RuntimeException("Unexpected exception " + _id ); 480 } 481 finally 482 { 483 this._releaseReply(_is); 484 } 485 } 486 else 487 { 488 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "get_txcontext", _opsClass ); 489 if( _so == null ) 490 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 491 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 492 org.omg.CosTransactions.PropagationContext _result; 493 try 494 { 495 _result = _localServant.get_txcontext(); 496 } 497 finally 498 { 499 _servant_postinvoke(_so); 500 } 501 return _result; 502 } 503 504 } 505 506 } 507 508 public void register_synchronization(org.omg.CosTransactions.Synchronization sync) throws org.omg.CosTransactions.SynchronizationUnavailable,org.omg.CosTransactions.Inactive 509 { 510 while(true) 511 { 512 if(! this._is_local()) 513 { 514 org.omg.CORBA.portable.InputStream _is = null; 515 try 516 { 517 org.omg.CORBA.portable.OutputStream _os = _request( "register_synchronization", true); 518 org.omg.CosTransactions.SynchronizationHelper.write(_os,sync); 519 _is = _invoke(_os); 520 return; 521 } 522 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 523 catch( org.omg.CORBA.portable.ApplicationException _ax ) 524 { 525 String _id = _ax.getId(); 526 if( _id.equals("IDL:CosTransactions/SynchronizationUnavailable:1.0")) 527 { 528 throw org.omg.CosTransactions.SynchronizationUnavailableHelper.read(_ax.getInputStream()); 529 } 530 else if( _id.equals("IDL:CosTransactions/Inactive:1.0")) 531 { 532 throw org.omg.CosTransactions.InactiveHelper.read(_ax.getInputStream()); 533 } 534 throw new RuntimeException("Unexpected exception " + _id ); 535 } 536 finally 537 { 538 this._releaseReply(_is); 539 } 540 } 541 else 542 { 543 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "register_synchronization", _opsClass ); 544 if( _so == null ) 545 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 546 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 547 try 548 { 549 _localServant.register_synchronization(sync); 550 } 551 finally 552 { 553 _servant_postinvoke(_so); 554 } 555 return; 556 } 557 558 } 559 560 } 561 562 public int hash_top_level_tran() 563 { 564 while(true) 565 { 566 if(! this._is_local()) 567 { 568 org.omg.CORBA.portable.InputStream _is = null; 569 try 570 { 571 org.omg.CORBA.portable.OutputStream _os = _request( "hash_top_level_tran", true); 572 _is = _invoke(_os); 573 int _result = _is.read_ulong(); 574 return _result; 575 } 576 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 577 catch( org.omg.CORBA.portable.ApplicationException _ax ) 578 { 579 String _id = _ax.getId(); 580 throw new RuntimeException("Unexpected exception " + _id ); 581 } 582 finally 583 { 584 this._releaseReply(_is); 585 } 586 } 587 else 588 { 589 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "hash_top_level_tran", _opsClass ); 590 if( _so == null ) 591 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 592 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 593 int _result; 594 try 595 { 596 _result = _localServant.hash_top_level_tran(); 597 } 598 finally 599 { 600 _servant_postinvoke(_so); 601 } 602 return _result; 603 } 604 605 } 606 607 } 608 609 public boolean is_same_transaction(org.omg.CosTransactions.Coordinator tc) 610 { 611 while(true) 612 { 613 if(! this._is_local()) 614 { 615 org.omg.CORBA.portable.InputStream _is = null; 616 try 617 { 618 org.omg.CORBA.portable.OutputStream _os = _request( "is_same_transaction", true); 619 org.omg.CosTransactions.CoordinatorHelper.write(_os,tc); 620 _is = _invoke(_os); 621 boolean _result = _is.read_boolean(); 622 return _result; 623 } 624 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 625 catch( org.omg.CORBA.portable.ApplicationException _ax ) 626 { 627 String _id = _ax.getId(); 628 throw new RuntimeException("Unexpected exception " + _id ); 629 } 630 finally 631 { 632 this._releaseReply(_is); 633 } 634 } 635 else 636 { 637 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "is_same_transaction", _opsClass ); 638 if( _so == null ) 639 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 640 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 641 boolean _result; 642 try 643 { 644 _result = _localServant.is_same_transaction(tc); 645 } 646 finally 647 { 648 _servant_postinvoke(_so); 649 } 650 return _result; 651 } 652 653 } 654 655 } 656 657 public void register_subtran_aware(org.omg.CosTransactions.SubtransactionAwareResource r) throws org.omg.CosTransactions.NotSubtransaction,org.omg.CosTransactions.Inactive 658 { 659 while(true) 660 { 661 if(! this._is_local()) 662 { 663 org.omg.CORBA.portable.InputStream _is = null; 664 try 665 { 666 org.omg.CORBA.portable.OutputStream _os = _request( "register_subtran_aware", true); 667 org.omg.CosTransactions.SubtransactionAwareResourceHelper.write(_os,r); 668 _is = _invoke(_os); 669 return; 670 } 671 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 672 catch( org.omg.CORBA.portable.ApplicationException _ax ) 673 { 674 String _id = _ax.getId(); 675 if( _id.equals("IDL:CosTransactions/NotSubtransaction:1.0")) 676 { 677 throw org.omg.CosTransactions.NotSubtransactionHelper.read(_ax.getInputStream()); 678 } 679 else if( _id.equals("IDL:CosTransactions/Inactive:1.0")) 680 { 681 throw org.omg.CosTransactions.InactiveHelper.read(_ax.getInputStream()); 682 } 683 throw new RuntimeException("Unexpected exception " + _id ); 684 } 685 finally 686 { 687 this._releaseReply(_is); 688 } 689 } 690 else 691 { 692 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "register_subtran_aware", _opsClass ); 693 if( _so == null ) 694 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 695 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 696 try 697 { 698 _localServant.register_subtran_aware(r); 699 } 700 finally 701 { 702 _servant_postinvoke(_so); 703 } 704 return; 705 } 706 707 } 708 709 } 710 711 public int hash_transaction() 712 { 713 while(true) 714 { 715 if(! this._is_local()) 716 { 717 org.omg.CORBA.portable.InputStream _is = null; 718 try 719 { 720 org.omg.CORBA.portable.OutputStream _os = _request( "hash_transaction", true); 721 _is = _invoke(_os); 722 int _result = _is.read_ulong(); 723 return _result; 724 } 725 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 726 catch( org.omg.CORBA.portable.ApplicationException _ax ) 727 { 728 String _id = _ax.getId(); 729 throw new RuntimeException("Unexpected exception " + _id ); 730 } 731 finally 732 { 733 this._releaseReply(_is); 734 } 735 } 736 else 737 { 738 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "hash_transaction", _opsClass ); 739 if( _so == null ) 740 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 741 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 742 int _result; 743 try 744 { 745 _result = _localServant.hash_transaction(); 746 } 747 finally 748 { 749 _servant_postinvoke(_so); 750 } 751 return _result; 752 } 753 754 } 755 756 } 757 758 public org.omg.CosTransactions.RecoveryCoordinator register_resource(org.omg.CosTransactions.Resource r) throws org.omg.CosTransactions.Inactive 759 { 760 while(true) 761 { 762 if(! this._is_local()) 763 { 764 org.omg.CORBA.portable.InputStream _is = null; 765 try 766 { 767 org.omg.CORBA.portable.OutputStream _os = _request( "register_resource", true); 768 org.omg.CosTransactions.ResourceHelper.write(_os,r); 769 _is = _invoke(_os); 770 org.omg.CosTransactions.RecoveryCoordinator _result = org.omg.CosTransactions.RecoveryCoordinatorHelper.read(_is); 771 return _result; 772 } 773 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 774 catch( org.omg.CORBA.portable.ApplicationException _ax ) 775 { 776 String _id = _ax.getId(); 777 if( _id.equals("IDL:CosTransactions/Inactive:1.0")) 778 { 779 throw org.omg.CosTransactions.InactiveHelper.read(_ax.getInputStream()); 780 } 781 throw new RuntimeException("Unexpected exception " + _id ); 782 } 783 finally 784 { 785 this._releaseReply(_is); 786 } 787 } 788 else 789 { 790 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "register_resource", _opsClass ); 791 if( _so == null ) 792 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 793 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 794 org.omg.CosTransactions.RecoveryCoordinator _result; 795 try 796 { 797 _result = _localServant.register_resource(r); 798 } 799 finally 800 { 801 _servant_postinvoke(_so); 802 } 803 return _result; 804 } 805 806 } 807 808 } 809 810 public boolean is_related_transaction(org.omg.CosTransactions.Coordinator tc) 811 { 812 while(true) 813 { 814 if(! this._is_local()) 815 { 816 org.omg.CORBA.portable.InputStream _is = null; 817 try 818 { 819 org.omg.CORBA.portable.OutputStream _os = _request( "is_related_transaction", true); 820 org.omg.CosTransactions.CoordinatorHelper.write(_os,tc); 821 _is = _invoke(_os); 822 boolean _result = _is.read_boolean(); 823 return _result; 824 } 825 catch( org.omg.CORBA.portable.RemarshalException _rx ){} 826 catch( org.omg.CORBA.portable.ApplicationException _ax ) 827 { 828 String _id = _ax.getId(); 829 throw new RuntimeException("Unexpected exception " + _id ); 830 } 831 finally 832 { 833 this._releaseReply(_is); 834 } 835 } 836 else 837 { 838 org.omg.CORBA.portable.ServantObject _so = _servant_preinvoke( "is_related_transaction", _opsClass ); 839 if( _so == null ) 840 throw new org.omg.CORBA.UNKNOWN("local invocations not supported!"); 841 CoordinatorOperations _localServant = (CoordinatorOperations)_so.servant; 842 boolean _result; 843 try 844 { 845 _result = _localServant.is_related_transaction(tc); 846 } 847 finally 848 { 849 _servant_postinvoke(_so); 850 } 851 return _result; 852 } 853 854 } 855 856 } 857 858 }