00001
00002 #ifndef __DataFlow_hh__
00003 #define __DataFlow_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_DataFlow
00011 #endif
00012 #ifndef USE_core_stub_in_nt_dll
00013 # define USE_core_stub_in_nt_dll_NOT_DEFINED_DataFlow
00014 #endif
00015 #ifndef USE_dyn_stub_in_nt_dll
00016 # define USE_dyn_stub_in_nt_dll_NOT_DEFINED_DataFlow
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 enum CFlowStatus { CNoData, COldData, CNewData };
00066 typedef CFlowStatus& CFlowStatus_out;
00067
00068 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CFlowStatus;
00069
00070 enum CConnectionModel { CData, CBuffer };
00071 typedef CConnectionModel& CConnectionModel_out;
00072
00073 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CConnectionModel;
00074
00075 enum CLockPolicy { CUnsync, CLocked, CLockFree };
00076 typedef CLockPolicy& CLockPolicy_out;
00077
00078 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CLockPolicy;
00079
00080 struct CConnPolicy {
00081 typedef _CORBA_ConstrType_Variable_Var<CConnPolicy> _var_type;
00082
00083
00084 CConnectionModel type;
00085
00086 ::CORBA::Boolean init;
00087
00088 CLockPolicy lock_policy;
00089
00090 ::CORBA::Boolean pull;
00091
00092 ::CORBA::Long size;
00093
00094 ::CORBA::Long transport;
00095
00096 ::CORBA::Long data_size;
00097
00098 ::CORBA::String_member name_id;
00099
00100
00101
00102 void operator>>= (cdrStream &) const;
00103 void operator<<= (cdrStream &);
00104 };
00105
00106 typedef CConnPolicy::_var_type CConnPolicy_var;
00107
00108 typedef _CORBA_ConstrType_Variable_OUT_arg< CConnPolicy,CConnPolicy_var > CConnPolicy_out;
00109
00110 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CConnPolicy;
00111
00112 #ifndef __RTT_mcorba_mCChannelElement__
00113 #define __RTT_mcorba_mCChannelElement__
00114
00115 class CChannelElement;
00116 class _objref_CChannelElement;
00117 class _impl_CChannelElement;
00118
00119 typedef _objref_CChannelElement* CChannelElement_ptr;
00120 typedef CChannelElement_ptr CChannelElementRef;
00121
00122 class CChannelElement_Helper {
00123 public:
00124 typedef CChannelElement_ptr _ptr_type;
00125
00126 static _ptr_type _nil();
00127 static _CORBA_Boolean is_nil(_ptr_type);
00128 static void release(_ptr_type);
00129 static void duplicate(_ptr_type);
00130 static void marshalObjRef(_ptr_type, cdrStream&);
00131 static _ptr_type unmarshalObjRef(cdrStream&);
00132 };
00133
00134 typedef _CORBA_ObjRef_Var<_objref_CChannelElement, CChannelElement_Helper> CChannelElement_var;
00135 typedef _CORBA_ObjRef_OUT_arg<_objref_CChannelElement,CChannelElement_Helper > CChannelElement_out;
00136
00137 #endif
00138
00139
00140 class CChannelElement {
00141 public:
00142
00143 typedef CChannelElement_ptr _ptr_type;
00144 typedef CChannelElement_var _var_type;
00145
00146 static _ptr_type _duplicate(_ptr_type);
00147 static _ptr_type _narrow(::CORBA::Object_ptr);
00148 static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
00149
00150 static _ptr_type _nil();
00151
00152 static inline void _marshalObjRef(_ptr_type, cdrStream&);
00153
00154 static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
00155 omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
00156 if (o)
00157 return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
00158 else
00159 return _nil();
00160 }
00161
00162 static _core_attr const char* _PD_repoId;
00163
00164
00165
00166 };
00167
00168 class _objref_CChannelElement :
00169 public virtual ::CORBA::Object,
00170 public virtual omniObjRef
00171 {
00172 public:
00173 CFlowStatus read(::CORBA::Any_OUT_arg sample, ::CORBA::Boolean copy_old_data);
00174 ::CORBA::Boolean write(const ::CORBA::Any& sample);
00175 void disconnect();
00176
00177 inline _objref_CChannelElement() { _PR_setobj(0); }
00178 _objref_CChannelElement(omniIOR*, omniIdentity*);
00179
00180 protected:
00181 virtual ~_objref_CChannelElement();
00182
00183
00184 private:
00185 virtual void* _ptrToObjRef(const char*);
00186
00187 _objref_CChannelElement(const _objref_CChannelElement&);
00188 _objref_CChannelElement& operator = (const _objref_CChannelElement&);
00189
00190
00191 friend class CChannelElement;
00192 };
00193
00194 class _pof_CChannelElement : public _OMNI_NS(proxyObjectFactory) {
00195 public:
00196 inline _pof_CChannelElement() : _OMNI_NS(proxyObjectFactory)(CChannelElement::_PD_repoId) {}
00197 virtual ~_pof_CChannelElement();
00198
00199 virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
00200 virtual _CORBA_Boolean is_a(const char*) const;
00201 };
00202
00203 class _impl_CChannelElement :
00204 public virtual omniServant
00205 {
00206 public:
00207 virtual ~_impl_CChannelElement();
00208
00209 virtual CFlowStatus read(::CORBA::Any_OUT_arg sample, ::CORBA::Boolean copy_old_data) = 0;
00210 virtual ::CORBA::Boolean write(const ::CORBA::Any& sample) = 0;
00211 virtual void disconnect() = 0;
00212
00213 public:
00214 virtual _CORBA_Boolean _dispatch(omniCallHandle&);
00215
00216 private:
00217 virtual void* _ptrToInterface(const char*);
00218 virtual const char* _mostDerivedRepoId();
00219
00220 };
00221
00222
00223 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CChannelElement;
00224
00225 #ifndef __RTT_mcorba_mCRemoteChannelElement__
00226 #define __RTT_mcorba_mCRemoteChannelElement__
00227
00228 class CRemoteChannelElement;
00229 class _objref_CRemoteChannelElement;
00230 class _impl_CRemoteChannelElement;
00231
00232 typedef _objref_CRemoteChannelElement* CRemoteChannelElement_ptr;
00233 typedef CRemoteChannelElement_ptr CRemoteChannelElementRef;
00234
00235 class CRemoteChannelElement_Helper {
00236 public:
00237 typedef CRemoteChannelElement_ptr _ptr_type;
00238
00239 static _ptr_type _nil();
00240 static _CORBA_Boolean is_nil(_ptr_type);
00241 static void release(_ptr_type);
00242 static void duplicate(_ptr_type);
00243 static void marshalObjRef(_ptr_type, cdrStream&);
00244 static _ptr_type unmarshalObjRef(cdrStream&);
00245 };
00246
00247 typedef _CORBA_ObjRef_Var<_objref_CRemoteChannelElement, CRemoteChannelElement_Helper> CRemoteChannelElement_var;
00248 typedef _CORBA_ObjRef_OUT_arg<_objref_CRemoteChannelElement,CRemoteChannelElement_Helper > CRemoteChannelElement_out;
00249
00250 #endif
00251
00252
00253 class CRemoteChannelElement {
00254 public:
00255
00256 typedef CRemoteChannelElement_ptr _ptr_type;
00257 typedef CRemoteChannelElement_var _var_type;
00258
00259 static _ptr_type _duplicate(_ptr_type);
00260 static _ptr_type _narrow(::CORBA::Object_ptr);
00261 static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
00262
00263 static _ptr_type _nil();
00264
00265 static inline void _marshalObjRef(_ptr_type, cdrStream&);
00266
00267 static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
00268 omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
00269 if (o)
00270 return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
00271 else
00272 return _nil();
00273 }
00274
00275 static _core_attr const char* _PD_repoId;
00276
00277
00278
00279 };
00280
00281 class _objref_CRemoteChannelElement :
00282 public virtual _objref_CChannelElement
00283 {
00284 public:
00285 void setRemoteSide(CRemoteChannelElement_ptr other);
00286 ::CORBA::Boolean remoteSignal();
00287 void remoteDisconnect(::CORBA::Boolean writer_to_reader);
00288
00289 inline _objref_CRemoteChannelElement() { _PR_setobj(0); }
00290 _objref_CRemoteChannelElement(omniIOR*, omniIdentity*);
00291
00292 protected:
00293 virtual ~_objref_CRemoteChannelElement();
00294
00295
00296 private:
00297 virtual void* _ptrToObjRef(const char*);
00298
00299 _objref_CRemoteChannelElement(const _objref_CRemoteChannelElement&);
00300 _objref_CRemoteChannelElement& operator = (const _objref_CRemoteChannelElement&);
00301
00302
00303 friend class CRemoteChannelElement;
00304 };
00305
00306 class _pof_CRemoteChannelElement : public _OMNI_NS(proxyObjectFactory) {
00307 public:
00308 inline _pof_CRemoteChannelElement() : _OMNI_NS(proxyObjectFactory)(CRemoteChannelElement::_PD_repoId) {}
00309 virtual ~_pof_CRemoteChannelElement();
00310
00311 virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
00312 virtual _CORBA_Boolean is_a(const char*) const;
00313 };
00314
00315 class _impl_CRemoteChannelElement :
00316 public virtual _impl_CChannelElement
00317 {
00318 public:
00319 virtual ~_impl_CRemoteChannelElement();
00320
00321 virtual void setRemoteSide(CRemoteChannelElement_ptr other) = 0;
00322 virtual ::CORBA::Boolean remoteSignal() = 0;
00323 virtual void remoteDisconnect(::CORBA::Boolean writer_to_reader) = 0;
00324
00325 public:
00326 virtual _CORBA_Boolean _dispatch(omniCallHandle&);
00327
00328 private:
00329 virtual void* _ptrToInterface(const char*);
00330 virtual const char* _mostDerivedRepoId();
00331
00332 };
00333
00334
00335 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CRemoteChannelElement;
00336
00337 class CNoSuchPortException : public ::CORBA::UserException {
00338 public:
00339
00340
00341
00342 inline CNoSuchPortException() {
00343 pd_insertToAnyFn = insertToAnyFn;
00344 pd_insertToAnyFnNCP = insertToAnyFnNCP;
00345 }
00346 CNoSuchPortException(const CNoSuchPortException&);
00347
00348 CNoSuchPortException& operator=(const CNoSuchPortException&);
00349 virtual ~CNoSuchPortException();
00350 virtual void _raise() const;
00351 static CNoSuchPortException* _downcast(::CORBA::Exception*);
00352 static const CNoSuchPortException* _downcast(const ::CORBA::Exception*);
00353 static inline CNoSuchPortException* _narrow(::CORBA::Exception* _e) {
00354 return _downcast(_e);
00355 }
00356
00357 inline void operator>>=(cdrStream&) const { }
00358 inline void operator<<=(cdrStream&) { }
00359
00360 static _core_attr insertExceptionToAny insertToAnyFn;
00361 static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;
00362
00363 virtual ::CORBA::Exception* _NP_duplicate() const;
00364
00365 static _core_attr const char* _PD_repoId;
00366 static _core_attr const char* _PD_typeId;
00367
00368 private:
00369 virtual const char* _NP_typeId() const;
00370 virtual const char* _NP_repoId(int*) const;
00371 virtual void _NP_marshal(cdrStream&) const;
00372 };
00373
00374 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CNoSuchPortException;
00375
00376 class CNoCorbaTransport : public ::CORBA::UserException {
00377 public:
00378
00379
00380
00381 inline CNoCorbaTransport() {
00382 pd_insertToAnyFn = insertToAnyFn;
00383 pd_insertToAnyFnNCP = insertToAnyFnNCP;
00384 }
00385 CNoCorbaTransport(const CNoCorbaTransport&);
00386
00387 CNoCorbaTransport& operator=(const CNoCorbaTransport&);
00388 virtual ~CNoCorbaTransport();
00389 virtual void _raise() const;
00390 static CNoCorbaTransport* _downcast(::CORBA::Exception*);
00391 static const CNoCorbaTransport* _downcast(const ::CORBA::Exception*);
00392 static inline CNoCorbaTransport* _narrow(::CORBA::Exception* _e) {
00393 return _downcast(_e);
00394 }
00395
00396 inline void operator>>=(cdrStream&) const { }
00397 inline void operator<<=(cdrStream&) { }
00398
00399 static _core_attr insertExceptionToAny insertToAnyFn;
00400 static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;
00401
00402 virtual ::CORBA::Exception* _NP_duplicate() const;
00403
00404 static _core_attr const char* _PD_repoId;
00405 static _core_attr const char* _PD_typeId;
00406
00407 private:
00408 virtual const char* _NP_typeId() const;
00409 virtual const char* _NP_repoId(int*) const;
00410 virtual void _NP_marshal(cdrStream&) const;
00411 };
00412
00413 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CNoCorbaTransport;
00414
00415 enum CPortType { CInput, COutput };
00416 typedef CPortType& CPortType_out;
00417
00418 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CPortType;
00419
00420 struct CPortDescription {
00421 typedef _CORBA_ConstrType_Variable_Var<CPortDescription> _var_type;
00422
00423
00424 CPortType type;
00425
00426 ::CORBA::String_member name;
00427
00428 ::CORBA::String_member type_name;
00429
00430
00431
00432 void operator>>= (cdrStream &) const;
00433 void operator<<= (cdrStream &);
00434 };
00435
00436 typedef CPortDescription::_var_type CPortDescription_var;
00437
00438 typedef _CORBA_ConstrType_Variable_OUT_arg< CPortDescription,CPortDescription_var > CPortDescription_out;
00439
00440 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CPortDescription;
00441
00442 #ifndef __RTT_mcorba_mCDataFlowInterface__
00443 #define __RTT_mcorba_mCDataFlowInterface__
00444
00445 class CDataFlowInterface;
00446 class _objref_CDataFlowInterface;
00447 class _impl_CDataFlowInterface;
00448
00449 typedef _objref_CDataFlowInterface* CDataFlowInterface_ptr;
00450 typedef CDataFlowInterface_ptr CDataFlowInterfaceRef;
00451
00452 class CDataFlowInterface_Helper {
00453 public:
00454 typedef CDataFlowInterface_ptr _ptr_type;
00455
00456 static _ptr_type _nil();
00457 static _CORBA_Boolean is_nil(_ptr_type);
00458 static void release(_ptr_type);
00459 static void duplicate(_ptr_type);
00460 static void marshalObjRef(_ptr_type, cdrStream&);
00461 static _ptr_type unmarshalObjRef(cdrStream&);
00462 };
00463
00464 typedef _CORBA_ObjRef_Var<_objref_CDataFlowInterface, CDataFlowInterface_Helper> CDataFlowInterface_var;
00465 typedef _CORBA_ObjRef_OUT_arg<_objref_CDataFlowInterface,CDataFlowInterface_Helper > CDataFlowInterface_out;
00466
00467 #endif
00468
00469
00470 class CDataFlowInterface {
00471 public:
00472
00473 typedef CDataFlowInterface_ptr _ptr_type;
00474 typedef CDataFlowInterface_var _var_type;
00475
00476 static _ptr_type _duplicate(_ptr_type);
00477 static _ptr_type _narrow(::CORBA::Object_ptr);
00478 static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
00479
00480 static _ptr_type _nil();
00481
00482 static inline void _marshalObjRef(_ptr_type, cdrStream&);
00483
00484 static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
00485 omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
00486 if (o)
00487 return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
00488 else
00489 return _nil();
00490 }
00491
00492 static _core_attr const char* _PD_repoId;
00493
00494
00495 static _dyn_attr const ::CORBA::TypeCode_ptr _tc_CPortNames;
00496
00497 class CPortNames_var;
00498
00499 class CPortNames : public _CORBA_Unbounded_Sequence_String {
00500 public:
00501 typedef CPortNames_var _var_type;
00502 inline CPortNames() {}
00503 inline CPortNames(const CPortNames& _s)
00504 : _CORBA_Unbounded_Sequence_String(_s) {}
00505
00506 inline CPortNames(_CORBA_ULong _max)
00507 : _CORBA_Unbounded_Sequence_String(_max) {}
00508 inline CPortNames(_CORBA_ULong _max, _CORBA_ULong _len, char** _val, _CORBA_Boolean _rel=0)
00509 : _CORBA_Unbounded_Sequence_String(_max, _len, _val, _rel) {}
00510
00511
00512
00513 inline CPortNames& operator = (const CPortNames& _s) {
00514 _CORBA_Unbounded_Sequence_String::operator=(_s);
00515 return *this;
00516 }
00517 };
00518
00519 class CPortNames_out;
00520
00521 class CPortNames_var {
00522 public:
00523 inline CPortNames_var() : _pd_seq(0) {}
00524 inline CPortNames_var(CPortNames* _s) : _pd_seq(_s) {}
00525 inline CPortNames_var(const CPortNames_var& _s) {
00526 if( _s._pd_seq ) _pd_seq = new CPortNames(*_s._pd_seq);
00527 else _pd_seq = 0;
00528 }
00529 inline ~CPortNames_var() { if( _pd_seq ) delete _pd_seq; }
00530
00531 inline CPortNames_var& operator = (CPortNames* _s) {
00532 if( _pd_seq ) delete _pd_seq;
00533 _pd_seq = _s;
00534 return *this;
00535 }
00536 inline CPortNames_var& operator = (const CPortNames_var& _s) {
00537 if( _s._pd_seq ) {
00538 if( !_pd_seq ) _pd_seq = new CPortNames;
00539 *_pd_seq = *_s._pd_seq;
00540 } else if( _pd_seq ) {
00541 delete _pd_seq;
00542 _pd_seq = 0;
00543 }
00544 return *this;
00545 }
00546 inline _CORBA_String_element operator [] (_CORBA_ULong _s) {
00547 return (*_pd_seq)[_s];
00548 }
00549
00550
00551
00552 inline CPortNames* operator -> () { return _pd_seq; }
00553 inline const CPortNames* operator -> () const { return _pd_seq; }
00554 #if defined(__GNUG__)
00555 inline operator CPortNames& () const { return *_pd_seq; }
00556 #else
00557 inline operator const CPortNames& () const { return *_pd_seq; }
00558 inline operator CPortNames& () { return *_pd_seq; }
00559 #endif
00560
00561 inline const CPortNames& in() const { return *_pd_seq; }
00562 inline CPortNames& inout() { return *_pd_seq; }
00563 inline CPortNames*& out() {
00564 if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
00565 return _pd_seq;
00566 }
00567 inline CPortNames* _retn() { CPortNames* tmp = _pd_seq; _pd_seq = 0; return tmp; }
00568
00569 friend class CPortNames_out;
00570
00571 private:
00572 CPortNames* _pd_seq;
00573 };
00574
00575 class CPortNames_out {
00576 public:
00577 inline CPortNames_out(CPortNames*& _s) : _data(_s) { _data = 0; }
00578 inline CPortNames_out(CPortNames_var& _s)
00579 : _data(_s._pd_seq) { _s = (CPortNames*) 0; }
00580 inline CPortNames_out(const CPortNames_out& _s) : _data(_s._data) {}
00581 inline CPortNames_out& operator = (const CPortNames_out& _s) {
00582 _data = _s._data;
00583 return *this;
00584 }
00585 inline CPortNames_out& operator = (CPortNames* _s) {
00586 _data = _s;
00587 return *this;
00588 }
00589 inline operator CPortNames*&() { return _data; }
00590 inline CPortNames*& ptr() { return _data; }
00591 inline CPortNames* operator->() { return _data; }
00592
00593 inline _CORBA_String_element operator [] (_CORBA_ULong _i) {
00594 return (*_data)[_i];
00595 }
00596
00597
00598
00599 CPortNames*& _data;
00600
00601 private:
00602 CPortNames_out();
00603 CPortNames_out& operator=(const CPortNames_var&);
00604 };
00605
00606 static _dyn_attr const ::CORBA::TypeCode_ptr _tc_CPortDescriptions;
00607
00608 class CPortDescriptions_var;
00609
00610 class CPortDescriptions : public _CORBA_Unbounded_Sequence< CPortDescription > {
00611 public:
00612 typedef CPortDescriptions_var _var_type;
00613 inline CPortDescriptions() {}
00614 inline CPortDescriptions(const CPortDescriptions& _s)
00615 : _CORBA_Unbounded_Sequence< CPortDescription > (_s) {}
00616
00617 inline CPortDescriptions(_CORBA_ULong _max)
00618 : _CORBA_Unbounded_Sequence< CPortDescription > (_max) {}
00619 inline CPortDescriptions(_CORBA_ULong _max, _CORBA_ULong _len, CPortDescription* _val, _CORBA_Boolean _rel=0)
00620 : _CORBA_Unbounded_Sequence< CPortDescription > (_max, _len, _val, _rel) {}
00621
00622
00623
00624 inline CPortDescriptions& operator = (const CPortDescriptions& _s) {
00625 _CORBA_Unbounded_Sequence< CPortDescription > ::operator=(_s);
00626 return *this;
00627 }
00628 };
00629
00630 class CPortDescriptions_out;
00631
00632 class CPortDescriptions_var {
00633 public:
00634 inline CPortDescriptions_var() : _pd_seq(0) {}
00635 inline CPortDescriptions_var(CPortDescriptions* _s) : _pd_seq(_s) {}
00636 inline CPortDescriptions_var(const CPortDescriptions_var& _s) {
00637 if( _s._pd_seq ) _pd_seq = new CPortDescriptions(*_s._pd_seq);
00638 else _pd_seq = 0;
00639 }
00640 inline ~CPortDescriptions_var() { if( _pd_seq ) delete _pd_seq; }
00641
00642 inline CPortDescriptions_var& operator = (CPortDescriptions* _s) {
00643 if( _pd_seq ) delete _pd_seq;
00644 _pd_seq = _s;
00645 return *this;
00646 }
00647 inline CPortDescriptions_var& operator = (const CPortDescriptions_var& _s) {
00648 if( _s._pd_seq ) {
00649 if( !_pd_seq ) _pd_seq = new CPortDescriptions;
00650 *_pd_seq = *_s._pd_seq;
00651 } else if( _pd_seq ) {
00652 delete _pd_seq;
00653 _pd_seq = 0;
00654 }
00655 return *this;
00656 }
00657 inline CPortDescription& operator [] (_CORBA_ULong _s) {
00658 return (*_pd_seq)[_s];
00659 }
00660
00661
00662
00663 inline CPortDescriptions* operator -> () { return _pd_seq; }
00664 inline const CPortDescriptions* operator -> () const { return _pd_seq; }
00665 #if defined(__GNUG__)
00666 inline operator CPortDescriptions& () const { return *_pd_seq; }
00667 #else
00668 inline operator const CPortDescriptions& () const { return *_pd_seq; }
00669 inline operator CPortDescriptions& () { return *_pd_seq; }
00670 #endif
00671
00672 inline const CPortDescriptions& in() const { return *_pd_seq; }
00673 inline CPortDescriptions& inout() { return *_pd_seq; }
00674 inline CPortDescriptions*& out() {
00675 if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
00676 return _pd_seq;
00677 }
00678 inline CPortDescriptions* _retn() { CPortDescriptions* tmp = _pd_seq; _pd_seq = 0; return tmp; }
00679
00680 friend class CPortDescriptions_out;
00681
00682 private:
00683 CPortDescriptions* _pd_seq;
00684 };
00685
00686 class CPortDescriptions_out {
00687 public:
00688 inline CPortDescriptions_out(CPortDescriptions*& _s) : _data(_s) { _data = 0; }
00689 inline CPortDescriptions_out(CPortDescriptions_var& _s)
00690 : _data(_s._pd_seq) { _s = (CPortDescriptions*) 0; }
00691 inline CPortDescriptions_out(const CPortDescriptions_out& _s) : _data(_s._data) {}
00692 inline CPortDescriptions_out& operator = (const CPortDescriptions_out& _s) {
00693 _data = _s._data;
00694 return *this;
00695 }
00696 inline CPortDescriptions_out& operator = (CPortDescriptions* _s) {
00697 _data = _s;
00698 return *this;
00699 }
00700 inline operator CPortDescriptions*&() { return _data; }
00701 inline CPortDescriptions*& ptr() { return _data; }
00702 inline CPortDescriptions* operator->() { return _data; }
00703
00704 inline CPortDescription& operator [] (_CORBA_ULong _i) {
00705 return (*_data)[_i];
00706 }
00707
00708
00709
00710 CPortDescriptions*& _data;
00711
00712 private:
00713 CPortDescriptions_out();
00714 CPortDescriptions_out& operator=(const CPortDescriptions_var&);
00715 };
00716
00717
00718 };
00719
00720 class _objref_CDataFlowInterface :
00721 public virtual ::CORBA::Object,
00722 public virtual omniObjRef
00723 {
00724 public:
00725 CDataFlowInterface::CPortNames* getPorts();
00726 CDataFlowInterface::CPortDescriptions* getPortDescriptions();
00727 CPortType getPortType(const char* port_name);
00728 char* getDataType(const char* port_name);
00729 ::CORBA::Boolean isConnected(const char* port_name);
00730 void disconnectPort(const char* port_name);
00731 CChannelElement_ptr buildChannelOutput(const char* input_port, CConnPolicy& policy);
00732 CChannelElement_ptr buildChannelInput(const char* output_port, CConnPolicy& policy);
00733 ::CORBA::Boolean createConnection(const char* local_port, CDataFlowInterface_ptr remote_ports, const char* remote_port, CConnPolicy& policy);
00734 ::CORBA::Boolean removeConnection(const char* local_port, CDataFlowInterface_ptr remote_ports, const char* remote_port);
00735 ::CORBA::Boolean createStream(const char* local_port, CConnPolicy& policy);
00736 void removeStream(const char* local_port, const char* stream_name);
00737 ::CORBA::Boolean channelReady(const char* input_port, CChannelElement_ptr channel);
00738
00739 inline _objref_CDataFlowInterface() { _PR_setobj(0); }
00740 _objref_CDataFlowInterface(omniIOR*, omniIdentity*);
00741
00742 protected:
00743 virtual ~_objref_CDataFlowInterface();
00744
00745
00746 private:
00747 virtual void* _ptrToObjRef(const char*);
00748
00749 _objref_CDataFlowInterface(const _objref_CDataFlowInterface&);
00750 _objref_CDataFlowInterface& operator = (const _objref_CDataFlowInterface&);
00751
00752
00753 friend class CDataFlowInterface;
00754 };
00755
00756 class _pof_CDataFlowInterface : public _OMNI_NS(proxyObjectFactory) {
00757 public:
00758 inline _pof_CDataFlowInterface() : _OMNI_NS(proxyObjectFactory)(CDataFlowInterface::_PD_repoId) {}
00759 virtual ~_pof_CDataFlowInterface();
00760
00761 virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
00762 virtual _CORBA_Boolean is_a(const char*) const;
00763 };
00764
00765 class _impl_CDataFlowInterface :
00766 public virtual omniServant
00767 {
00768 public:
00769 virtual ~_impl_CDataFlowInterface();
00770
00771 virtual CDataFlowInterface::CPortNames* getPorts() = 0;
00772 virtual CDataFlowInterface::CPortDescriptions* getPortDescriptions() = 0;
00773 virtual CPortType getPortType(const char* port_name) = 0;
00774 virtual char* getDataType(const char* port_name) = 0;
00775 virtual ::CORBA::Boolean isConnected(const char* port_name) = 0;
00776 virtual void disconnectPort(const char* port_name) = 0;
00777 virtual CChannelElement_ptr buildChannelOutput(const char* input_port, CConnPolicy& policy) = 0;
00778 virtual CChannelElement_ptr buildChannelInput(const char* output_port, CConnPolicy& policy) = 0;
00779 virtual ::CORBA::Boolean createConnection(const char* local_port, CDataFlowInterface_ptr remote_ports, const char* remote_port, CConnPolicy& policy) = 0;
00780 virtual ::CORBA::Boolean removeConnection(const char* local_port, CDataFlowInterface_ptr remote_ports, const char* remote_port) = 0;
00781 virtual ::CORBA::Boolean createStream(const char* local_port, CConnPolicy& policy) = 0;
00782 virtual void removeStream(const char* local_port, const char* stream_name) = 0;
00783 virtual ::CORBA::Boolean channelReady(const char* input_port, CChannelElement_ptr channel) = 0;
00784
00785 public:
00786 virtual _CORBA_Boolean _dispatch(omniCallHandle&);
00787
00788 private:
00789 virtual void* _ptrToInterface(const char*);
00790 virtual const char* _mostDerivedRepoId();
00791
00792 };
00793
00794
00795 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CDataFlowInterface;
00796
00797 _CORBA_MODULE_END
00798
00799 _CORBA_MODULE_END
00800
00801
00802
00803 _CORBA_MODULE POA_RTT
00804 _CORBA_MODULE_BEG
00805
00806 _CORBA_MODULE corba
00807 _CORBA_MODULE_BEG
00808
00809 class CChannelElement :
00810 public virtual RTT::corba::_impl_CChannelElement,
00811 public virtual ::PortableServer::ServantBase
00812 {
00813 public:
00814 virtual ~CChannelElement();
00815
00816 inline ::RTT::corba::CChannelElement_ptr _this() {
00817 return (::RTT::corba::CChannelElement_ptr) _do_this(::RTT::corba::CChannelElement::_PD_repoId);
00818 }
00819 };
00820
00821 class CRemoteChannelElement :
00822 public virtual RTT::corba::_impl_CRemoteChannelElement,
00823 public virtual CChannelElement
00824 {
00825 public:
00826 virtual ~CRemoteChannelElement();
00827
00828 inline ::RTT::corba::CRemoteChannelElement_ptr _this() {
00829 return (::RTT::corba::CRemoteChannelElement_ptr) _do_this(::RTT::corba::CRemoteChannelElement::_PD_repoId);
00830 }
00831 };
00832
00833 class CDataFlowInterface :
00834 public virtual RTT::corba::_impl_CDataFlowInterface,
00835 public virtual ::PortableServer::ServantBase
00836 {
00837 public:
00838 virtual ~CDataFlowInterface();
00839
00840 inline ::RTT::corba::CDataFlowInterface_ptr _this() {
00841 return (::RTT::corba::CDataFlowInterface_ptr) _do_this(::RTT::corba::CDataFlowInterface::_PD_repoId);
00842 }
00843 };
00844
00845 _CORBA_MODULE_END
00846
00847 _CORBA_MODULE_END
00848
00849
00850
00851 _CORBA_MODULE OBV_RTT
00852 _CORBA_MODULE_BEG
00853
00854 _CORBA_MODULE corba
00855 _CORBA_MODULE_BEG
00856
00857 _CORBA_MODULE_END
00858
00859 _CORBA_MODULE_END
00860
00861
00862
00863
00864
00865 #undef _core_attr
00866 #undef _dyn_attr
00867
00868 inline void operator >>=(RTT::corba::CFlowStatus _e, cdrStream& s) {
00869 ::operator>>=((::CORBA::ULong)_e, s);
00870 }
00871
00872 inline void operator <<= (RTT::corba::CFlowStatus& _e, cdrStream& s) {
00873 ::CORBA::ULong _0RL_e;
00874 ::operator<<=(_0RL_e,s);
00875 if (_0RL_e <= RTT::corba::CNewData) {
00876 _e = (RTT::corba::CFlowStatus) _0RL_e;
00877 }
00878 else {
00879 OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
00880 (::CORBA::CompletionStatus)s.completion());
00881 }
00882 }
00883
00884 void operator<<=(::CORBA::Any& _a, RTT::corba::CFlowStatus _s);
00885 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CFlowStatus& _s);
00886
00887 inline void operator >>=(RTT::corba::CConnectionModel _e, cdrStream& s) {
00888 ::operator>>=((::CORBA::ULong)_e, s);
00889 }
00890
00891 inline void operator <<= (RTT::corba::CConnectionModel& _e, cdrStream& s) {
00892 ::CORBA::ULong _0RL_e;
00893 ::operator<<=(_0RL_e,s);
00894 if (_0RL_e <= RTT::corba::CBuffer) {
00895 _e = (RTT::corba::CConnectionModel) _0RL_e;
00896 }
00897 else {
00898 OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
00899 (::CORBA::CompletionStatus)s.completion());
00900 }
00901 }
00902
00903 void operator<<=(::CORBA::Any& _a, RTT::corba::CConnectionModel _s);
00904 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CConnectionModel& _s);
00905
00906 inline void operator >>=(RTT::corba::CLockPolicy _e, cdrStream& s) {
00907 ::operator>>=((::CORBA::ULong)_e, s);
00908 }
00909
00910 inline void operator <<= (RTT::corba::CLockPolicy& _e, cdrStream& s) {
00911 ::CORBA::ULong _0RL_e;
00912 ::operator<<=(_0RL_e,s);
00913 if (_0RL_e <= RTT::corba::CLockFree) {
00914 _e = (RTT::corba::CLockPolicy) _0RL_e;
00915 }
00916 else {
00917 OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
00918 (::CORBA::CompletionStatus)s.completion());
00919 }
00920 }
00921
00922 void operator<<=(::CORBA::Any& _a, RTT::corba::CLockPolicy _s);
00923 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CLockPolicy& _s);
00924
00925 extern void operator<<=(::CORBA::Any& _a, const RTT::corba::CConnPolicy& _s);
00926 extern void operator<<=(::CORBA::Any& _a, RTT::corba::CConnPolicy* _sp);
00927 extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CConnPolicy*& _sp);
00928 extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CConnPolicy*& _sp);
00929
00930 void operator<<=(::CORBA::Any& _a, RTT::corba::CChannelElement_ptr _s);
00931 void operator<<=(::CORBA::Any& _a, RTT::corba::CChannelElement_ptr* _s);
00932 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CChannelElement_ptr& _s);
00933
00934 void operator<<=(::CORBA::Any& _a, RTT::corba::CRemoteChannelElement_ptr _s);
00935 void operator<<=(::CORBA::Any& _a, RTT::corba::CRemoteChannelElement_ptr* _s);
00936 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CRemoteChannelElement_ptr& _s);
00937
00938 void operator<<=(::CORBA::Any& _a, const RTT::corba::CNoSuchPortException& _s);
00939 void operator<<=(::CORBA::Any& _a, const RTT::corba::CNoSuchPortException* _sp);
00940 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CNoSuchPortException*& _sp);
00941
00942 void operator<<=(::CORBA::Any& _a, const RTT::corba::CNoCorbaTransport& _s);
00943 void operator<<=(::CORBA::Any& _a, const RTT::corba::CNoCorbaTransport* _sp);
00944 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CNoCorbaTransport*& _sp);
00945
00946 inline void operator >>=(RTT::corba::CPortType _e, cdrStream& s) {
00947 ::operator>>=((::CORBA::ULong)_e, s);
00948 }
00949
00950 inline void operator <<= (RTT::corba::CPortType& _e, cdrStream& s) {
00951 ::CORBA::ULong _0RL_e;
00952 ::operator<<=(_0RL_e,s);
00953 if (_0RL_e <= RTT::corba::COutput) {
00954 _e = (RTT::corba::CPortType) _0RL_e;
00955 }
00956 else {
00957 OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
00958 (::CORBA::CompletionStatus)s.completion());
00959 }
00960 }
00961
00962 void operator<<=(::CORBA::Any& _a, RTT::corba::CPortType _s);
00963 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CPortType& _s);
00964
00965 extern void operator<<=(::CORBA::Any& _a, const RTT::corba::CPortDescription& _s);
00966 extern void operator<<=(::CORBA::Any& _a, RTT::corba::CPortDescription* _sp);
00967 extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CPortDescription*& _sp);
00968 extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CPortDescription*& _sp);
00969
00970 void operator<<=(::CORBA::Any& _a, const RTT::corba::CDataFlowInterface::CPortNames& _s);
00971 void operator<<=(::CORBA::Any& _a, RTT::corba::CDataFlowInterface::CPortNames* _sp);
00972 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CDataFlowInterface::CPortNames*& _sp);
00973 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CDataFlowInterface::CPortNames*& _sp);
00974
00975 void operator<<=(::CORBA::Any& _a, const RTT::corba::CDataFlowInterface::CPortDescriptions& _s);
00976 void operator<<=(::CORBA::Any& _a, RTT::corba::CDataFlowInterface::CPortDescriptions* _sp);
00977 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CDataFlowInterface::CPortDescriptions*& _sp);
00978 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CDataFlowInterface::CPortDescriptions*& _sp);
00979
00980 void operator<<=(::CORBA::Any& _a, RTT::corba::CDataFlowInterface_ptr _s);
00981 void operator<<=(::CORBA::Any& _a, RTT::corba::CDataFlowInterface_ptr* _s);
00982 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CDataFlowInterface_ptr& _s);
00983
00984
00985
00986 inline void
00987 RTT::corba::CChannelElement::_marshalObjRef(::RTT::corba::CChannelElement_ptr obj, cdrStream& s) {
00988 omniObjRef::_marshal(obj->_PR_getobj(),s);
00989 }
00990
00991
00992 inline void
00993 RTT::corba::CRemoteChannelElement::_marshalObjRef(::RTT::corba::CRemoteChannelElement_ptr obj, cdrStream& s) {
00994 omniObjRef::_marshal(obj->_PR_getobj(),s);
00995 }
00996
00997
00998 inline void
00999 RTT::corba::CDataFlowInterface::_marshalObjRef(::RTT::corba::CDataFlowInterface_ptr obj, cdrStream& s) {
01000 omniObjRef::_marshal(obj->_PR_getobj(),s);
01001 }
01002
01003
01004
01005
01006 #ifdef USE_stub_in_nt_dll_NOT_DEFINED_DataFlow
01007 # undef USE_stub_in_nt_dll
01008 # undef USE_stub_in_nt_dll_NOT_DEFINED_DataFlow
01009 #endif
01010 #ifdef USE_core_stub_in_nt_dll_NOT_DEFINED_DataFlow
01011 # undef USE_core_stub_in_nt_dll
01012 # undef USE_core_stub_in_nt_dll_NOT_DEFINED_DataFlow
01013 #endif
01014 #ifdef USE_dyn_stub_in_nt_dll_NOT_DEFINED_DataFlow
01015 # undef USE_dyn_stub_in_nt_dll
01016 # undef USE_dyn_stub_in_nt_dll_NOT_DEFINED_DataFlow
01017 #endif
01018
01019 #endif // __DataFlow_hh__
01020
