00001
00002 #ifndef __OperationInterface_hh__
00003 #define __OperationInterface_hh__
00004
00005 #ifndef __CORBA_H_EXTERNAL_GUARD__
00006 #include <omniORB4/CORBA.h>
00007 #endif
00008
00009 #ifndef USE_stub_in_nt_dll
00010 # define USE_stub_in_nt_dll_NOT_DEFINED_OperationInterface
00011 #endif
00012 #ifndef USE_core_stub_in_nt_dll
00013 # define USE_core_stub_in_nt_dll_NOT_DEFINED_OperationInterface
00014 #endif
00015 #ifndef USE_dyn_stub_in_nt_dll
00016 # define USE_dyn_stub_in_nt_dll_NOT_DEFINED_OperationInterface
00017 #endif
00018
00019
00020
00021
00022
00023
00024 #ifdef USE_stub_in_nt_dll
00025 # ifndef USE_core_stub_in_nt_dll
00026 # define USE_core_stub_in_nt_dll
00027 # endif
00028 # ifndef USE_dyn_stub_in_nt_dll
00029 # define USE_dyn_stub_in_nt_dll
00030 # endif
00031 #endif
00032
00033 #ifdef _core_attr
00034 # error "A local CPP macro _core_attr has already been defined."
00035 #else
00036 # ifdef USE_core_stub_in_nt_dll
00037 # define _core_attr _OMNIORB_NTDLL_IMPORT
00038 # else
00039 # define _core_attr
00040 # endif
00041 #endif
00042
00043 #ifdef _dyn_attr
00044 # error "A local CPP macro _dyn_attr has already been defined."
00045 #else
00046 # ifdef USE_dyn_stub_in_nt_dll
00047 # define _dyn_attr _OMNIORB_NTDLL_IMPORT
00048 # else
00049 # define _dyn_attr
00050 # endif
00051 #endif
00052
00053
00054
00055
00056
00057 _CORBA_MODULE RTT
00058
00059 _CORBA_MODULE_BEG
00060
00061 _CORBA_MODULE corba
00062
00063 _CORBA_MODULE_BEG
00064
00065 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CAnyArguments;
00066
00067 class CAnyArguments_var;
00068
00069 class CAnyArguments : public _CORBA_Unbounded_Sequence< ::CORBA::Any > {
00070 public:
00071 typedef CAnyArguments_var _var_type;
00072 inline CAnyArguments() {}
00073 inline CAnyArguments(const CAnyArguments& _s)
00074 : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_s) {}
00075
00076 inline CAnyArguments(_CORBA_ULong _max)
00077 : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_max) {}
00078 inline CAnyArguments(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Any* _val, _CORBA_Boolean _rel=0)
00079 : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_max, _len, _val, _rel) {}
00080
00081
00082
00083 inline CAnyArguments& operator = (const CAnyArguments& _s) {
00084 _CORBA_Unbounded_Sequence< ::CORBA::Any > ::operator=(_s);
00085 return *this;
00086 }
00087 };
00088
00089 class CAnyArguments_out;
00090
00091 class CAnyArguments_var {
00092 public:
00093 inline CAnyArguments_var() : _pd_seq(0) {}
00094 inline CAnyArguments_var(CAnyArguments* _s) : _pd_seq(_s) {}
00095 inline CAnyArguments_var(const CAnyArguments_var& _s) {
00096 if( _s._pd_seq ) _pd_seq = new CAnyArguments(*_s._pd_seq);
00097 else _pd_seq = 0;
00098 }
00099 inline ~CAnyArguments_var() { if( _pd_seq ) delete _pd_seq; }
00100
00101 inline CAnyArguments_var& operator = (CAnyArguments* _s) {
00102 if( _pd_seq ) delete _pd_seq;
00103 _pd_seq = _s;
00104 return *this;
00105 }
00106 inline CAnyArguments_var& operator = (const CAnyArguments_var& _s) {
00107 if( _s._pd_seq ) {
00108 if( !_pd_seq ) _pd_seq = new CAnyArguments;
00109 *_pd_seq = *_s._pd_seq;
00110 } else if( _pd_seq ) {
00111 delete _pd_seq;
00112 _pd_seq = 0;
00113 }
00114 return *this;
00115 }
00116 inline ::CORBA::Any& operator [] (_CORBA_ULong _s) {
00117 return (*_pd_seq)[_s];
00118 }
00119
00120
00121
00122 inline CAnyArguments* operator -> () { return _pd_seq; }
00123 inline const CAnyArguments* operator -> () const { return _pd_seq; }
00124 #if defined(__GNUG__)
00125 inline operator CAnyArguments& () const { return *_pd_seq; }
00126 #else
00127 inline operator const CAnyArguments& () const { return *_pd_seq; }
00128 inline operator CAnyArguments& () { return *_pd_seq; }
00129 #endif
00130
00131 inline const CAnyArguments& in() const { return *_pd_seq; }
00132 inline CAnyArguments& inout() { return *_pd_seq; }
00133 inline CAnyArguments*& out() {
00134 if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
00135 return _pd_seq;
00136 }
00137 inline CAnyArguments* _retn() { CAnyArguments* tmp = _pd_seq; _pd_seq = 0; return tmp; }
00138
00139 friend class CAnyArguments_out;
00140
00141 private:
00142 CAnyArguments* _pd_seq;
00143 };
00144
00145 class CAnyArguments_out {
00146 public:
00147 inline CAnyArguments_out(CAnyArguments*& _s) : _data(_s) { _data = 0; }
00148 inline CAnyArguments_out(CAnyArguments_var& _s)
00149 : _data(_s._pd_seq) { _s = (CAnyArguments*) 0; }
00150 inline CAnyArguments_out(const CAnyArguments_out& _s) : _data(_s._data) {}
00151 inline CAnyArguments_out& operator = (const CAnyArguments_out& _s) {
00152 _data = _s._data;
00153 return *this;
00154 }
00155 inline CAnyArguments_out& operator = (CAnyArguments* _s) {
00156 _data = _s;
00157 return *this;
00158 }
00159 inline operator CAnyArguments*&() { return _data; }
00160 inline CAnyArguments*& ptr() { return _data; }
00161 inline CAnyArguments* operator->() { return _data; }
00162
00163 inline ::CORBA::Any& operator [] (_CORBA_ULong _i) {
00164 return (*_data)[_i];
00165 }
00166
00167
00168
00169 CAnyArguments*& _data;
00170
00171 private:
00172 CAnyArguments_out();
00173 CAnyArguments_out& operator=(const CAnyArguments_var&);
00174 };
00175
00176 struct CArgumentDescription {
00177 typedef _CORBA_ConstrType_Variable_Var<CArgumentDescription> _var_type;
00178
00179
00180 ::CORBA::String_member name;
00181
00182 ::CORBA::String_member description;
00183
00184 ::CORBA::String_member type;
00185
00186
00187
00188 void operator>>= (cdrStream &) const;
00189 void operator<<= (cdrStream &);
00190 };
00191
00192 typedef CArgumentDescription::_var_type CArgumentDescription_var;
00193
00194 typedef _CORBA_ConstrType_Variable_OUT_arg< CArgumentDescription,CArgumentDescription_var > CArgumentDescription_out;
00195
00196 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CArgumentDescription;
00197
00198 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CDescriptions;
00199
00200 class CDescriptions_var;
00201
00202 class CDescriptions : public _CORBA_Unbounded_Sequence< CArgumentDescription > {
00203 public:
00204 typedef CDescriptions_var _var_type;
00205 inline CDescriptions() {}
00206 inline CDescriptions(const CDescriptions& _s)
00207 : _CORBA_Unbounded_Sequence< CArgumentDescription > (_s) {}
00208
00209 inline CDescriptions(_CORBA_ULong _max)
00210 : _CORBA_Unbounded_Sequence< CArgumentDescription > (_max) {}
00211 inline CDescriptions(_CORBA_ULong _max, _CORBA_ULong _len, CArgumentDescription* _val, _CORBA_Boolean _rel=0)
00212 : _CORBA_Unbounded_Sequence< CArgumentDescription > (_max, _len, _val, _rel) {}
00213
00214
00215
00216 inline CDescriptions& operator = (const CDescriptions& _s) {
00217 _CORBA_Unbounded_Sequence< CArgumentDescription > ::operator=(_s);
00218 return *this;
00219 }
00220 };
00221
00222 class CDescriptions_out;
00223
00224 class CDescriptions_var {
00225 public:
00226 inline CDescriptions_var() : _pd_seq(0) {}
00227 inline CDescriptions_var(CDescriptions* _s) : _pd_seq(_s) {}
00228 inline CDescriptions_var(const CDescriptions_var& _s) {
00229 if( _s._pd_seq ) _pd_seq = new CDescriptions(*_s._pd_seq);
00230 else _pd_seq = 0;
00231 }
00232 inline ~CDescriptions_var() { if( _pd_seq ) delete _pd_seq; }
00233
00234 inline CDescriptions_var& operator = (CDescriptions* _s) {
00235 if( _pd_seq ) delete _pd_seq;
00236 _pd_seq = _s;
00237 return *this;
00238 }
00239 inline CDescriptions_var& operator = (const CDescriptions_var& _s) {
00240 if( _s._pd_seq ) {
00241 if( !_pd_seq ) _pd_seq = new CDescriptions;
00242 *_pd_seq = *_s._pd_seq;
00243 } else if( _pd_seq ) {
00244 delete _pd_seq;
00245 _pd_seq = 0;
00246 }
00247 return *this;
00248 }
00249 inline CArgumentDescription& operator [] (_CORBA_ULong _s) {
00250 return (*_pd_seq)[_s];
00251 }
00252
00253
00254
00255 inline CDescriptions* operator -> () { return _pd_seq; }
00256 inline const CDescriptions* operator -> () const { return _pd_seq; }
00257 #if defined(__GNUG__)
00258 inline operator CDescriptions& () const { return *_pd_seq; }
00259 #else
00260 inline operator const CDescriptions& () const { return *_pd_seq; }
00261 inline operator CDescriptions& () { return *_pd_seq; }
00262 #endif
00263
00264 inline const CDescriptions& in() const { return *_pd_seq; }
00265 inline CDescriptions& inout() { return *_pd_seq; }
00266 inline CDescriptions*& out() {
00267 if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
00268 return _pd_seq;
00269 }
00270 inline CDescriptions* _retn() { CDescriptions* tmp = _pd_seq; _pd_seq = 0; return tmp; }
00271
00272 friend class CDescriptions_out;
00273
00274 private:
00275 CDescriptions* _pd_seq;
00276 };
00277
00278 class CDescriptions_out {
00279 public:
00280 inline CDescriptions_out(CDescriptions*& _s) : _data(_s) { _data = 0; }
00281 inline CDescriptions_out(CDescriptions_var& _s)
00282 : _data(_s._pd_seq) { _s = (CDescriptions*) 0; }
00283 inline CDescriptions_out(const CDescriptions_out& _s) : _data(_s._data) {}
00284 inline CDescriptions_out& operator = (const CDescriptions_out& _s) {
00285 _data = _s._data;
00286 return *this;
00287 }
00288 inline CDescriptions_out& operator = (CDescriptions* _s) {
00289 _data = _s;
00290 return *this;
00291 }
00292 inline operator CDescriptions*&() { return _data; }
00293 inline CDescriptions*& ptr() { return _data; }
00294 inline CDescriptions* operator->() { return _data; }
00295
00296 inline CArgumentDescription& operator [] (_CORBA_ULong _i) {
00297 return (*_data)[_i];
00298 }
00299
00300
00301
00302 CDescriptions*& _data;
00303
00304 private:
00305 CDescriptions_out();
00306 CDescriptions_out& operator=(const CDescriptions_var&);
00307 };
00308
00309 class CWrongArgumentException : public ::CORBA::UserException {
00310 public:
00311
00312 ::CORBA::Long which_arg;
00313
00314 ::CORBA::Long max_arg;
00315
00316
00317
00318 inline CWrongArgumentException() {
00319 pd_insertToAnyFn = insertToAnyFn;
00320 pd_insertToAnyFnNCP = insertToAnyFnNCP;
00321 }
00322 CWrongArgumentException(const CWrongArgumentException&);
00323 CWrongArgumentException(::CORBA::Long i_which_arg, ::CORBA::Long i_max_arg);
00324 CWrongArgumentException& operator=(const CWrongArgumentException&);
00325 virtual ~CWrongArgumentException();
00326 virtual void _raise() const;
00327 static CWrongArgumentException* _downcast(::CORBA::Exception*);
00328 static const CWrongArgumentException* _downcast(const ::CORBA::Exception*);
00329 static inline CWrongArgumentException* _narrow(::CORBA::Exception* _e) {
00330 return _downcast(_e);
00331 }
00332
00333 void operator>>=(cdrStream&) const ;
00334 void operator<<=(cdrStream&) ;
00335
00336 static _core_attr insertExceptionToAny insertToAnyFn;
00337 static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;
00338
00339 virtual ::CORBA::Exception* _NP_duplicate() const;
00340
00341 static _core_attr const char* _PD_repoId;
00342 static _core_attr const char* _PD_typeId;
00343
00344 private:
00345 virtual const char* _NP_typeId() const;
00346 virtual const char* _NP_repoId(int*) const;
00347 virtual void _NP_marshal(cdrStream&) const;
00348 };
00349
00350 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CWrongArgumentException;
00351
00352 class CWrongNumbArgException : public ::CORBA::UserException {
00353 public:
00354
00355 ::CORBA::Long wanted;
00356
00357 ::CORBA::Long received;
00358
00359
00360
00361 inline CWrongNumbArgException() {
00362 pd_insertToAnyFn = insertToAnyFn;
00363 pd_insertToAnyFnNCP = insertToAnyFnNCP;
00364 }
00365 CWrongNumbArgException(const CWrongNumbArgException&);
00366 CWrongNumbArgException(::CORBA::Long i_wanted, ::CORBA::Long i_received);
00367 CWrongNumbArgException& operator=(const CWrongNumbArgException&);
00368 virtual ~CWrongNumbArgException();
00369 virtual void _raise() const;
00370 static CWrongNumbArgException* _downcast(::CORBA::Exception*);
00371 static const CWrongNumbArgException* _downcast(const ::CORBA::Exception*);
00372 static inline CWrongNumbArgException* _narrow(::CORBA::Exception* _e) {
00373 return _downcast(_e);
00374 }
00375
00376 void operator>>=(cdrStream&) const ;
00377 void operator<<=(cdrStream&) ;
00378
00379 static _core_attr insertExceptionToAny insertToAnyFn;
00380 static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;
00381
00382 virtual ::CORBA::Exception* _NP_duplicate() const;
00383
00384 static _core_attr const char* _PD_repoId;
00385 static _core_attr const char* _PD_typeId;
00386
00387 private:
00388 virtual const char* _NP_typeId() const;
00389 virtual const char* _NP_repoId(int*) const;
00390 virtual void _NP_marshal(cdrStream&) const;
00391 };
00392
00393 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CWrongNumbArgException;
00394
00395 class CWrongTypeArgException : public ::CORBA::UserException {
00396 public:
00397
00398 ::CORBA::Long whicharg;
00399
00400 ::CORBA::String_member expected;
00401
00402 ::CORBA::String_member received;
00403
00404
00405
00406 inline CWrongTypeArgException() {
00407 pd_insertToAnyFn = insertToAnyFn;
00408 pd_insertToAnyFnNCP = insertToAnyFnNCP;
00409 }
00410 CWrongTypeArgException(const CWrongTypeArgException&);
00411 CWrongTypeArgException(::CORBA::Long i_whicharg, const char* i_expected, const char* i_received);
00412 CWrongTypeArgException& operator=(const CWrongTypeArgException&);
00413 virtual ~CWrongTypeArgException();
00414 virtual void _raise() const;
00415 static CWrongTypeArgException* _downcast(::CORBA::Exception*);
00416 static const CWrongTypeArgException* _downcast(const ::CORBA::Exception*);
00417 static inline CWrongTypeArgException* _narrow(::CORBA::Exception* _e) {
00418 return _downcast(_e);
00419 }
00420
00421 void operator>>=(cdrStream&) const ;
00422 void operator<<=(cdrStream&) ;
00423
00424 static _core_attr insertExceptionToAny insertToAnyFn;
00425 static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;
00426
00427 virtual ::CORBA::Exception* _NP_duplicate() const;
00428
00429 static _core_attr const char* _PD_repoId;
00430 static _core_attr const char* _PD_typeId;
00431
00432 private:
00433 virtual const char* _NP_typeId() const;
00434 virtual const char* _NP_repoId(int*) const;
00435 virtual void _NP_marshal(cdrStream&) const;
00436 };
00437
00438 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CWrongTypeArgException;
00439
00440 class CNoSuchNameException : public ::CORBA::UserException {
00441 public:
00442
00443 ::CORBA::String_member name;
00444
00445
00446
00447 inline CNoSuchNameException() {
00448 pd_insertToAnyFn = insertToAnyFn;
00449 pd_insertToAnyFnNCP = insertToAnyFnNCP;
00450 }
00451 CNoSuchNameException(const CNoSuchNameException&);
00452 CNoSuchNameException(const char* i_name);
00453 CNoSuchNameException& operator=(const CNoSuchNameException&);
00454 virtual ~CNoSuchNameException();
00455 virtual void _raise() const;
00456 static CNoSuchNameException* _downcast(::CORBA::Exception*);
00457 static const CNoSuchNameException* _downcast(const ::CORBA::Exception*);
00458 static inline CNoSuchNameException* _narrow(::CORBA::Exception* _e) {
00459 return _downcast(_e);
00460 }
00461
00462 void operator>>=(cdrStream&) const ;
00463 void operator<<=(cdrStream&) ;
00464
00465 static _core_attr insertExceptionToAny insertToAnyFn;
00466 static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;
00467
00468 virtual ::CORBA::Exception* _NP_duplicate() const;
00469
00470 static _core_attr const char* _PD_repoId;
00471 static _core_attr const char* _PD_typeId;
00472
00473 private:
00474 virtual const char* _NP_typeId() const;
00475 virtual const char* _NP_repoId(int*) const;
00476 virtual void _NP_marshal(cdrStream&) const;
00477 };
00478
00479 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CNoSuchNameException;
00480
00481 enum CSendStatus { CSendFailure, CSendNotReady, CSendSuccess };
00482 typedef CSendStatus& CSendStatus_out;
00483
00484 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CSendStatus;
00485
00486 class CCallInterrupted : public ::CORBA::UserException {
00487 public:
00488
00489
00490
00491 inline CCallInterrupted() {
00492 pd_insertToAnyFn = insertToAnyFn;
00493 pd_insertToAnyFnNCP = insertToAnyFnNCP;
00494 }
00495 CCallInterrupted(const CCallInterrupted&);
00496
00497 CCallInterrupted& operator=(const CCallInterrupted&);
00498 virtual ~CCallInterrupted();
00499 virtual void _raise() const;
00500 static CCallInterrupted* _downcast(::CORBA::Exception*);
00501 static const CCallInterrupted* _downcast(const ::CORBA::Exception*);
00502 static inline CCallInterrupted* _narrow(::CORBA::Exception* _e) {
00503 return _downcast(_e);
00504 }
00505
00506 inline void operator>>=(cdrStream&) const { }
00507 inline void operator<<=(cdrStream&) { }
00508
00509 static _core_attr insertExceptionToAny insertToAnyFn;
00510 static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;
00511
00512 virtual ::CORBA::Exception* _NP_duplicate() const;
00513
00514 static _core_attr const char* _PD_repoId;
00515 static _core_attr const char* _PD_typeId;
00516
00517 private:
00518 virtual const char* _NP_typeId() const;
00519 virtual const char* _NP_repoId(int*) const;
00520 virtual void _NP_marshal(cdrStream&) const;
00521 };
00522
00523 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CCallInterrupted;
00524
00525 #ifndef __RTT_mcorba_mCSendHandle__
00526 #define __RTT_mcorba_mCSendHandle__
00527
00528 class CSendHandle;
00529 class _objref_CSendHandle;
00530 class _impl_CSendHandle;
00531
00532 typedef _objref_CSendHandle* CSendHandle_ptr;
00533 typedef CSendHandle_ptr CSendHandleRef;
00534
00535 class CSendHandle_Helper {
00536 public:
00537 typedef CSendHandle_ptr _ptr_type;
00538
00539 static _ptr_type _nil();
00540 static _CORBA_Boolean is_nil(_ptr_type);
00541 static void release(_ptr_type);
00542 static void duplicate(_ptr_type);
00543 static void marshalObjRef(_ptr_type, cdrStream&);
00544 static _ptr_type unmarshalObjRef(cdrStream&);
00545 };
00546
00547 typedef _CORBA_ObjRef_Var<_objref_CSendHandle, CSendHandle_Helper> CSendHandle_var;
00548 typedef _CORBA_ObjRef_OUT_arg<_objref_CSendHandle,CSendHandle_Helper > CSendHandle_out;
00549
00550 #endif
00551
00552
00553 class CSendHandle {
00554 public:
00555
00556 typedef CSendHandle_ptr _ptr_type;
00557 typedef CSendHandle_var _var_type;
00558
00559 static _ptr_type _duplicate(_ptr_type);
00560 static _ptr_type _narrow(::CORBA::Object_ptr);
00561 static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
00562
00563 static _ptr_type _nil();
00564
00565 static inline void _marshalObjRef(_ptr_type, cdrStream&);
00566
00567 static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
00568 omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
00569 if (o)
00570 return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
00571 else
00572 return _nil();
00573 }
00574
00575 static _core_attr const char* _PD_repoId;
00576
00577
00578
00579 };
00580
00581 class _objref_CSendHandle :
00582 public virtual ::CORBA::Object,
00583 public virtual omniObjRef
00584 {
00585 public:
00586 CSendStatus collect(CAnyArguments_out args);
00587 CSendStatus collectIfDone(CAnyArguments_out args);
00588 CSendStatus checkStatus();
00589 ::CORBA::Any* ret();
00590 void checkArguments(const CAnyArguments& args);
00591 void dispose();
00592
00593 inline _objref_CSendHandle() { _PR_setobj(0); }
00594 _objref_CSendHandle(omniIOR*, omniIdentity*);
00595
00596 protected:
00597 virtual ~_objref_CSendHandle();
00598
00599
00600 private:
00601 virtual void* _ptrToObjRef(const char*);
00602
00603 _objref_CSendHandle(const _objref_CSendHandle&);
00604 _objref_CSendHandle& operator = (const _objref_CSendHandle&);
00605
00606
00607 friend class CSendHandle;
00608 };
00609
00610 class _pof_CSendHandle : public _OMNI_NS(proxyObjectFactory) {
00611 public:
00612 inline _pof_CSendHandle() : _OMNI_NS(proxyObjectFactory)(CSendHandle::_PD_repoId) {}
00613 virtual ~_pof_CSendHandle();
00614
00615 virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
00616 virtual _CORBA_Boolean is_a(const char*) const;
00617 };
00618
00619 class _impl_CSendHandle :
00620 public virtual omniServant
00621 {
00622 public:
00623 virtual ~_impl_CSendHandle();
00624
00625 virtual CSendStatus collect(CAnyArguments_out args) = 0;
00626 virtual CSendStatus collectIfDone(CAnyArguments_out args) = 0;
00627 virtual CSendStatus checkStatus() = 0;
00628 virtual ::CORBA::Any* ret() = 0;
00629 virtual void checkArguments(const CAnyArguments& args) = 0;
00630 virtual void dispose() = 0;
00631
00632 public:
00633 virtual _CORBA_Boolean _dispatch(omniCallHandle&);
00634
00635 private:
00636 virtual void* _ptrToInterface(const char*);
00637 virtual const char* _mostDerivedRepoId();
00638
00639 };
00640
00641
00642 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CSendHandle;
00643
00644 #ifndef __RTT_mcorba_mCOperationInterface__
00645 #define __RTT_mcorba_mCOperationInterface__
00646
00647 class COperationInterface;
00648 class _objref_COperationInterface;
00649 class _impl_COperationInterface;
00650
00651 typedef _objref_COperationInterface* COperationInterface_ptr;
00652 typedef COperationInterface_ptr COperationInterfaceRef;
00653
00654 class COperationInterface_Helper {
00655 public:
00656 typedef COperationInterface_ptr _ptr_type;
00657
00658 static _ptr_type _nil();
00659 static _CORBA_Boolean is_nil(_ptr_type);
00660 static void release(_ptr_type);
00661 static void duplicate(_ptr_type);
00662 static void marshalObjRef(_ptr_type, cdrStream&);
00663 static _ptr_type unmarshalObjRef(cdrStream&);
00664 };
00665
00666 typedef _CORBA_ObjRef_Var<_objref_COperationInterface, COperationInterface_Helper> COperationInterface_var;
00667 typedef _CORBA_ObjRef_OUT_arg<_objref_COperationInterface,COperationInterface_Helper > COperationInterface_out;
00668
00669 #endif
00670
00671
00672 class COperationInterface {
00673 public:
00674
00675 typedef COperationInterface_ptr _ptr_type;
00676 typedef COperationInterface_var _var_type;
00677
00678 static _ptr_type _duplicate(_ptr_type);
00679 static _ptr_type _narrow(::CORBA::Object_ptr);
00680 static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
00681
00682 static _ptr_type _nil();
00683
00684 static inline void _marshalObjRef(_ptr_type, cdrStream&);
00685
00686 static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
00687 omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
00688 if (o)
00689 return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
00690 else
00691 return _nil();
00692 }
00693
00694 static _core_attr const char* _PD_repoId;
00695
00696
00697 static _dyn_attr const ::CORBA::TypeCode_ptr _tc_COperationList;
00698
00699 class COperationList_var;
00700
00701 class COperationList : public _CORBA_Unbounded_Sequence_String {
00702 public:
00703 typedef COperationList_var _var_type;
00704 inline COperationList() {}
00705 inline COperationList(const COperationList& _s)
00706 : _CORBA_Unbounded_Sequence_String(_s) {}
00707
00708 inline COperationList(_CORBA_ULong _max)
00709 : _CORBA_Unbounded_Sequence_String(_max) {}
00710 inline COperationList(_CORBA_ULong _max, _CORBA_ULong _len, char** _val, _CORBA_Boolean _rel=0)
00711 : _CORBA_Unbounded_Sequence_String(_max, _len, _val, _rel) {}
00712
00713
00714
00715 inline COperationList& operator = (const COperationList& _s) {
00716 _CORBA_Unbounded_Sequence_String::operator=(_s);
00717 return *this;
00718 }
00719 };
00720
00721 class COperationList_out;
00722
00723 class COperationList_var {
00724 public:
00725 inline COperationList_var() : _pd_seq(0) {}
00726 inline COperationList_var(COperationList* _s) : _pd_seq(_s) {}
00727 inline COperationList_var(const COperationList_var& _s) {
00728 if( _s._pd_seq ) _pd_seq = new COperationList(*_s._pd_seq);
00729 else _pd_seq = 0;
00730 }
00731 inline ~COperationList_var() { if( _pd_seq ) delete _pd_seq; }
00732
00733 inline COperationList_var& operator = (COperationList* _s) {
00734 if( _pd_seq ) delete _pd_seq;
00735 _pd_seq = _s;
00736 return *this;
00737 }
00738 inline COperationList_var& operator = (const COperationList_var& _s) {
00739 if( _s._pd_seq ) {
00740 if( !_pd_seq ) _pd_seq = new COperationList;
00741 *_pd_seq = *_s._pd_seq;
00742 } else if( _pd_seq ) {
00743 delete _pd_seq;
00744 _pd_seq = 0;
00745 }
00746 return *this;
00747 }
00748 inline _CORBA_String_element operator [] (_CORBA_ULong _s) {
00749 return (*_pd_seq)[_s];
00750 }
00751
00752
00753
00754 inline COperationList* operator -> () { return _pd_seq; }
00755 inline const COperationList* operator -> () const { return _pd_seq; }
00756 #if defined(__GNUG__)
00757 inline operator COperationList& () const { return *_pd_seq; }
00758 #else
00759 inline operator const COperationList& () const { return *_pd_seq; }
00760 inline operator COperationList& () { return *_pd_seq; }
00761 #endif
00762
00763 inline const COperationList& in() const { return *_pd_seq; }
00764 inline COperationList& inout() { return *_pd_seq; }
00765 inline COperationList*& out() {
00766 if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
00767 return _pd_seq;
00768 }
00769 inline COperationList* _retn() { COperationList* tmp = _pd_seq; _pd_seq = 0; return tmp; }
00770
00771 friend class COperationList_out;
00772
00773 private:
00774 COperationList* _pd_seq;
00775 };
00776
00777 class COperationList_out {
00778 public:
00779 inline COperationList_out(COperationList*& _s) : _data(_s) { _data = 0; }
00780 inline COperationList_out(COperationList_var& _s)
00781 : _data(_s._pd_seq) { _s = (COperationList*) 0; }
00782 inline COperationList_out(const COperationList_out& _s) : _data(_s._data) {}
00783 inline COperationList_out& operator = (const COperationList_out& _s) {
00784 _data = _s._data;
00785 return *this;
00786 }
00787 inline COperationList_out& operator = (COperationList* _s) {
00788 _data = _s;
00789 return *this;
00790 }
00791 inline operator COperationList*&() { return _data; }
00792 inline COperationList*& ptr() { return _data; }
00793 inline COperationList* operator->() { return _data; }
00794
00795 inline _CORBA_String_element operator [] (_CORBA_ULong _i) {
00796 return (*_data)[_i];
00797 }
00798
00799
00800
00801 COperationList*& _data;
00802
00803 private:
00804 COperationList_out();
00805 COperationList_out& operator=(const COperationList_var&);
00806 };
00807
00808
00809 };
00810
00811 class _objref_COperationInterface :
00812 public virtual ::CORBA::Object,
00813 public virtual omniObjRef
00814 {
00815 public:
00816 COperationInterface::COperationList* getOperations();
00817 CDescriptions* getArguments(const char* operation);
00818 ::CORBA::UShort getArity(const char* operation);
00819 ::CORBA::UShort getCollectArity(const char* operation);
00820 char* getResultType(const char* operation);
00821 char* getArgumentType(const char* operation, ::CORBA::UShort nbr);
00822 char* getCollectType(const char* operation, ::CORBA::UShort nbr);
00823 char* getDescription(const char* operation);
00824 void checkOperation(const char* operation, const CAnyArguments& args);
00825 ::CORBA::Any* callOperation(const char* operation, CAnyArguments& args);
00826 CSendHandle_ptr sendOperation(const char* operation, const CAnyArguments& args);
00827
00828 inline _objref_COperationInterface() { _PR_setobj(0); }
00829 _objref_COperationInterface(omniIOR*, omniIdentity*);
00830
00831 protected:
00832 virtual ~_objref_COperationInterface();
00833
00834
00835 private:
00836 virtual void* _ptrToObjRef(const char*);
00837
00838 _objref_COperationInterface(const _objref_COperationInterface&);
00839 _objref_COperationInterface& operator = (const _objref_COperationInterface&);
00840
00841
00842 friend class COperationInterface;
00843 };
00844
00845 class _pof_COperationInterface : public _OMNI_NS(proxyObjectFactory) {
00846 public:
00847 inline _pof_COperationInterface() : _OMNI_NS(proxyObjectFactory)(COperationInterface::_PD_repoId) {}
00848 virtual ~_pof_COperationInterface();
00849
00850 virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
00851 virtual _CORBA_Boolean is_a(const char*) const;
00852 };
00853
00854 class _impl_COperationInterface :
00855 public virtual omniServant
00856 {
00857 public:
00858 virtual ~_impl_COperationInterface();
00859
00860 virtual COperationInterface::COperationList* getOperations() = 0;
00861 virtual CDescriptions* getArguments(const char* operation) = 0;
00862 virtual ::CORBA::UShort getArity(const char* operation) = 0;
00863 virtual ::CORBA::UShort getCollectArity(const char* operation) = 0;
00864 virtual char* getResultType(const char* operation) = 0;
00865 virtual char* getArgumentType(const char* operation, ::CORBA::UShort nbr) = 0;
00866 virtual char* getCollectType(const char* operation, ::CORBA::UShort nbr) = 0;
00867 virtual char* getDescription(const char* operation) = 0;
00868 virtual void checkOperation(const char* operation, const CAnyArguments& args) = 0;
00869 virtual ::CORBA::Any* callOperation(const char* operation, CAnyArguments& args) = 0;
00870 virtual CSendHandle_ptr sendOperation(const char* operation, const CAnyArguments& args) = 0;
00871
00872 public:
00873 virtual _CORBA_Boolean _dispatch(omniCallHandle&);
00874
00875 private:
00876 virtual void* _ptrToInterface(const char*);
00877 virtual const char* _mostDerivedRepoId();
00878
00879 };
00880
00881
00882 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_COperationInterface;
00883
00884 _CORBA_MODULE_END
00885
00886 _CORBA_MODULE_END
00887
00888
00889
00890 _CORBA_MODULE POA_RTT
00891 _CORBA_MODULE_BEG
00892
00893 _CORBA_MODULE corba
00894 _CORBA_MODULE_BEG
00895
00896 class CSendHandle :
00897 public virtual RTT::corba::_impl_CSendHandle,
00898 public virtual ::PortableServer::ServantBase
00899 {
00900 public:
00901 virtual ~CSendHandle();
00902
00903 inline ::RTT::corba::CSendHandle_ptr _this() {
00904 return (::RTT::corba::CSendHandle_ptr) _do_this(::RTT::corba::CSendHandle::_PD_repoId);
00905 }
00906 };
00907
00908 class COperationInterface :
00909 public virtual RTT::corba::_impl_COperationInterface,
00910 public virtual ::PortableServer::ServantBase
00911 {
00912 public:
00913 virtual ~COperationInterface();
00914
00915 inline ::RTT::corba::COperationInterface_ptr _this() {
00916 return (::RTT::corba::COperationInterface_ptr) _do_this(::RTT::corba::COperationInterface::_PD_repoId);
00917 }
00918 };
00919
00920 _CORBA_MODULE_END
00921
00922 _CORBA_MODULE_END
00923
00924
00925
00926 _CORBA_MODULE OBV_RTT
00927 _CORBA_MODULE_BEG
00928
00929 _CORBA_MODULE corba
00930 _CORBA_MODULE_BEG
00931
00932 _CORBA_MODULE_END
00933
00934 _CORBA_MODULE_END
00935
00936
00937
00938
00939
00940 #undef _core_attr
00941 #undef _dyn_attr
00942
00943 void operator<<=(::CORBA::Any& _a, const RTT::corba::CAnyArguments& _s);
00944 void operator<<=(::CORBA::Any& _a, RTT::corba::CAnyArguments* _sp);
00945 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CAnyArguments*& _sp);
00946 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CAnyArguments*& _sp);
00947
00948 extern void operator<<=(::CORBA::Any& _a, const RTT::corba::CArgumentDescription& _s);
00949 extern void operator<<=(::CORBA::Any& _a, RTT::corba::CArgumentDescription* _sp);
00950 extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CArgumentDescription*& _sp);
00951 extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CArgumentDescription*& _sp);
00952
00953 void operator<<=(::CORBA::Any& _a, const RTT::corba::CDescriptions& _s);
00954 void operator<<=(::CORBA::Any& _a, RTT::corba::CDescriptions* _sp);
00955 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CDescriptions*& _sp);
00956 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CDescriptions*& _sp);
00957
00958 void operator<<=(::CORBA::Any& _a, const RTT::corba::CWrongArgumentException& _s);
00959 void operator<<=(::CORBA::Any& _a, const RTT::corba::CWrongArgumentException* _sp);
00960 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CWrongArgumentException*& _sp);
00961
00962 void operator<<=(::CORBA::Any& _a, const RTT::corba::CWrongNumbArgException& _s);
00963 void operator<<=(::CORBA::Any& _a, const RTT::corba::CWrongNumbArgException* _sp);
00964 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CWrongNumbArgException*& _sp);
00965
00966 void operator<<=(::CORBA::Any& _a, const RTT::corba::CWrongTypeArgException& _s);
00967 void operator<<=(::CORBA::Any& _a, const RTT::corba::CWrongTypeArgException* _sp);
00968 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CWrongTypeArgException*& _sp);
00969
00970 void operator<<=(::CORBA::Any& _a, const RTT::corba::CNoSuchNameException& _s);
00971 void operator<<=(::CORBA::Any& _a, const RTT::corba::CNoSuchNameException* _sp);
00972 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CNoSuchNameException*& _sp);
00973
00974 inline void operator >>=(RTT::corba::CSendStatus _e, cdrStream& s) {
00975 ::operator>>=((::CORBA::ULong)_e, s);
00976 }
00977
00978 inline void operator <<= (RTT::corba::CSendStatus& _e, cdrStream& s) {
00979 ::CORBA::ULong _0RL_e;
00980 ::operator<<=(_0RL_e,s);
00981 if (_0RL_e <= RTT::corba::CSendSuccess) {
00982 _e = (RTT::corba::CSendStatus) _0RL_e;
00983 }
00984 else {
00985 OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
00986 (::CORBA::CompletionStatus)s.completion());
00987 }
00988 }
00989
00990 void operator<<=(::CORBA::Any& _a, RTT::corba::CSendStatus _s);
00991 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CSendStatus& _s);
00992
00993 void operator<<=(::CORBA::Any& _a, const RTT::corba::CCallInterrupted& _s);
00994 void operator<<=(::CORBA::Any& _a, const RTT::corba::CCallInterrupted* _sp);
00995 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CCallInterrupted*& _sp);
00996
00997 void operator<<=(::CORBA::Any& _a, RTT::corba::CSendHandle_ptr _s);
00998 void operator<<=(::CORBA::Any& _a, RTT::corba::CSendHandle_ptr* _s);
00999 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CSendHandle_ptr& _s);
01000
01001 void operator<<=(::CORBA::Any& _a, const RTT::corba::COperationInterface::COperationList& _s);
01002 void operator<<=(::CORBA::Any& _a, RTT::corba::COperationInterface::COperationList* _sp);
01003 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::COperationInterface::COperationList*& _sp);
01004 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::COperationInterface::COperationList*& _sp);
01005
01006 void operator<<=(::CORBA::Any& _a, RTT::corba::COperationInterface_ptr _s);
01007 void operator<<=(::CORBA::Any& _a, RTT::corba::COperationInterface_ptr* _s);
01008 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::COperationInterface_ptr& _s);
01009
01010
01011
01012 inline void
01013 RTT::corba::CSendHandle::_marshalObjRef(::RTT::corba::CSendHandle_ptr obj, cdrStream& s) {
01014 omniObjRef::_marshal(obj->_PR_getobj(),s);
01015 }
01016
01017
01018 inline void
01019 RTT::corba::COperationInterface::_marshalObjRef(::RTT::corba::COperationInterface_ptr obj, cdrStream& s) {
01020 omniObjRef::_marshal(obj->_PR_getobj(),s);
01021 }
01022
01023
01024
01025
01026 #ifdef USE_stub_in_nt_dll_NOT_DEFINED_OperationInterface
01027 # undef USE_stub_in_nt_dll
01028 # undef USE_stub_in_nt_dll_NOT_DEFINED_OperationInterface
01029 #endif
01030 #ifdef USE_core_stub_in_nt_dll_NOT_DEFINED_OperationInterface
01031 # undef USE_core_stub_in_nt_dll
01032 # undef USE_core_stub_in_nt_dll_NOT_DEFINED_OperationInterface
01033 #endif
01034 #ifdef USE_dyn_stub_in_nt_dll_NOT_DEFINED_OperationInterface
01035 # undef USE_dyn_stub_in_nt_dll
01036 # undef USE_dyn_stub_in_nt_dll_NOT_DEFINED_OperationInterface
01037 #endif
01038
01039 #endif // __OperationInterface_hh__
01040
