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 Jun 18, 2012 10:37:00 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    }