00001
00002 #ifndef __OrocosTypes_hh__
00003 #define __OrocosTypes_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_OrocosTypes
00011 #endif
00012 #ifndef USE_core_stub_in_nt_dll
00013 # define USE_core_stub_in_nt_dll_NOT_DEFINED_OrocosTypes
00014 #endif
00015 #ifndef USE_dyn_stub_in_nt_dll
00016 # define USE_dyn_stub_in_nt_dll_NOT_DEFINED_OrocosTypes
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 struct Pair {
00066 typedef _CORBA_ConstrType_Variable_Var<Pair> _var_type;
00067
00068
00069 ::CORBA::Any t1;
00070
00071 ::CORBA::Any t2;
00072
00073
00074
00075 void operator>>= (cdrStream &) const;
00076 void operator<<= (cdrStream &);
00077 };
00078
00079 typedef Pair::_var_type Pair_var;
00080
00081 typedef _CORBA_ConstrType_Variable_OUT_arg< Pair,Pair_var > Pair_out;
00082
00083 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Pair;
00084
00085 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CAnySequence;
00086
00087 class CAnySequence_var;
00088
00089 class CAnySequence : public _CORBA_Unbounded_Sequence< ::CORBA::Any > {
00090 public:
00091 typedef CAnySequence_var _var_type;
00092 inline CAnySequence() {}
00093 inline CAnySequence(const CAnySequence& _s)
00094 : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_s) {}
00095
00096 inline CAnySequence(_CORBA_ULong _max)
00097 : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_max) {}
00098 inline CAnySequence(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Any* _val, _CORBA_Boolean _rel=0)
00099 : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_max, _len, _val, _rel) {}
00100
00101
00102
00103 inline CAnySequence& operator = (const CAnySequence& _s) {
00104 _CORBA_Unbounded_Sequence< ::CORBA::Any > ::operator=(_s);
00105 return *this;
00106 }
00107 };
00108
00109 class CAnySequence_out;
00110
00111 class CAnySequence_var {
00112 public:
00113 inline CAnySequence_var() : _pd_seq(0) {}
00114 inline CAnySequence_var(CAnySequence* _s) : _pd_seq(_s) {}
00115 inline CAnySequence_var(const CAnySequence_var& _s) {
00116 if( _s._pd_seq ) _pd_seq = new CAnySequence(*_s._pd_seq);
00117 else _pd_seq = 0;
00118 }
00119 inline ~CAnySequence_var() { if( _pd_seq ) delete _pd_seq; }
00120
00121 inline CAnySequence_var& operator = (CAnySequence* _s) {
00122 if( _pd_seq ) delete _pd_seq;
00123 _pd_seq = _s;
00124 return *this;
00125 }
00126 inline CAnySequence_var& operator = (const CAnySequence_var& _s) {
00127 if( _s._pd_seq ) {
00128 if( !_pd_seq ) _pd_seq = new CAnySequence;
00129 *_pd_seq = *_s._pd_seq;
00130 } else if( _pd_seq ) {
00131 delete _pd_seq;
00132 _pd_seq = 0;
00133 }
00134 return *this;
00135 }
00136 inline ::CORBA::Any& operator [] (_CORBA_ULong _s) {
00137 return (*_pd_seq)[_s];
00138 }
00139
00140
00141
00142 inline CAnySequence* operator -> () { return _pd_seq; }
00143 inline const CAnySequence* operator -> () const { return _pd_seq; }
00144 #if defined(__GNUG__)
00145 inline operator CAnySequence& () const { return *_pd_seq; }
00146 #else
00147 inline operator const CAnySequence& () const { return *_pd_seq; }
00148 inline operator CAnySequence& () { return *_pd_seq; }
00149 #endif
00150
00151 inline const CAnySequence& in() const { return *_pd_seq; }
00152 inline CAnySequence& inout() { return *_pd_seq; }
00153 inline CAnySequence*& out() {
00154 if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
00155 return _pd_seq;
00156 }
00157 inline CAnySequence* _retn() { CAnySequence* tmp = _pd_seq; _pd_seq = 0; return tmp; }
00158
00159 friend class CAnySequence_out;
00160
00161 private:
00162 CAnySequence* _pd_seq;
00163 };
00164
00165 class CAnySequence_out {
00166 public:
00167 inline CAnySequence_out(CAnySequence*& _s) : _data(_s) { _data = 0; }
00168 inline CAnySequence_out(CAnySequence_var& _s)
00169 : _data(_s._pd_seq) { _s = (CAnySequence*) 0; }
00170 inline CAnySequence_out(const CAnySequence_out& _s) : _data(_s._data) {}
00171 inline CAnySequence_out& operator = (const CAnySequence_out& _s) {
00172 _data = _s._data;
00173 return *this;
00174 }
00175 inline CAnySequence_out& operator = (CAnySequence* _s) {
00176 _data = _s;
00177 return *this;
00178 }
00179 inline operator CAnySequence*&() { return _data; }
00180 inline CAnySequence*& ptr() { return _data; }
00181 inline CAnySequence* operator->() { return _data; }
00182
00183 inline ::CORBA::Any& operator [] (_CORBA_ULong _i) {
00184 return (*_data)[_i];
00185 }
00186
00187
00188
00189 CAnySequence*& _data;
00190
00191 private:
00192 CAnySequence_out();
00193 CAnySequence_out& operator=(const CAnySequence_var&);
00194 };
00195
00196 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PairSeq;
00197
00198 class PairSeq_var;
00199
00200 class PairSeq : public _CORBA_Unbounded_Sequence< Pair > {
00201 public:
00202 typedef PairSeq_var _var_type;
00203 inline PairSeq() {}
00204 inline PairSeq(const PairSeq& _s)
00205 : _CORBA_Unbounded_Sequence< Pair > (_s) {}
00206
00207 inline PairSeq(_CORBA_ULong _max)
00208 : _CORBA_Unbounded_Sequence< Pair > (_max) {}
00209 inline PairSeq(_CORBA_ULong _max, _CORBA_ULong _len, Pair* _val, _CORBA_Boolean _rel=0)
00210 : _CORBA_Unbounded_Sequence< Pair > (_max, _len, _val, _rel) {}
00211
00212
00213
00214 inline PairSeq& operator = (const PairSeq& _s) {
00215 _CORBA_Unbounded_Sequence< Pair > ::operator=(_s);
00216 return *this;
00217 }
00218 };
00219
00220 class PairSeq_out;
00221
00222 class PairSeq_var {
00223 public:
00224 inline PairSeq_var() : _pd_seq(0) {}
00225 inline PairSeq_var(PairSeq* _s) : _pd_seq(_s) {}
00226 inline PairSeq_var(const PairSeq_var& _s) {
00227 if( _s._pd_seq ) _pd_seq = new PairSeq(*_s._pd_seq);
00228 else _pd_seq = 0;
00229 }
00230 inline ~PairSeq_var() { if( _pd_seq ) delete _pd_seq; }
00231
00232 inline PairSeq_var& operator = (PairSeq* _s) {
00233 if( _pd_seq ) delete _pd_seq;
00234 _pd_seq = _s;
00235 return *this;
00236 }
00237 inline PairSeq_var& operator = (const PairSeq_var& _s) {
00238 if( _s._pd_seq ) {
00239 if( !_pd_seq ) _pd_seq = new PairSeq;
00240 *_pd_seq = *_s._pd_seq;
00241 } else if( _pd_seq ) {
00242 delete _pd_seq;
00243 _pd_seq = 0;
00244 }
00245 return *this;
00246 }
00247 inline Pair& operator [] (_CORBA_ULong _s) {
00248 return (*_pd_seq)[_s];
00249 }
00250
00251
00252
00253 inline PairSeq* operator -> () { return _pd_seq; }
00254 inline const PairSeq* operator -> () const { return _pd_seq; }
00255 #if defined(__GNUG__)
00256 inline operator PairSeq& () const { return *_pd_seq; }
00257 #else
00258 inline operator const PairSeq& () const { return *_pd_seq; }
00259 inline operator PairSeq& () { return *_pd_seq; }
00260 #endif
00261
00262 inline const PairSeq& in() const { return *_pd_seq; }
00263 inline PairSeq& inout() { return *_pd_seq; }
00264 inline PairSeq*& out() {
00265 if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
00266 return _pd_seq;
00267 }
00268 inline PairSeq* _retn() { PairSeq* tmp = _pd_seq; _pd_seq = 0; return tmp; }
00269
00270 friend class PairSeq_out;
00271
00272 private:
00273 PairSeq* _pd_seq;
00274 };
00275
00276 class PairSeq_out {
00277 public:
00278 inline PairSeq_out(PairSeq*& _s) : _data(_s) { _data = 0; }
00279 inline PairSeq_out(PairSeq_var& _s)
00280 : _data(_s._pd_seq) { _s = (PairSeq*) 0; }
00281 inline PairSeq_out(const PairSeq_out& _s) : _data(_s._data) {}
00282 inline PairSeq_out& operator = (const PairSeq_out& _s) {
00283 _data = _s._data;
00284 return *this;
00285 }
00286 inline PairSeq_out& operator = (PairSeq* _s) {
00287 _data = _s;
00288 return *this;
00289 }
00290 inline operator PairSeq*&() { return _data; }
00291 inline PairSeq*& ptr() { return _data; }
00292 inline PairSeq* operator->() { return _data; }
00293
00294 inline Pair& operator [] (_CORBA_ULong _i) {
00295 return (*_data)[_i];
00296 }
00297
00298
00299
00300 PairSeq*& _data;
00301
00302 private:
00303 PairSeq_out();
00304 PairSeq_out& operator=(const PairSeq_var&);
00305 };
00306
00307 _CORBA_MODULE_END
00308
00309 _CORBA_MODULE_END
00310
00311
00312
00313 _CORBA_MODULE POA_RTT
00314 _CORBA_MODULE_BEG
00315
00316 _CORBA_MODULE corba
00317 _CORBA_MODULE_BEG
00318
00319 _CORBA_MODULE_END
00320
00321 _CORBA_MODULE_END
00322
00323
00324
00325 _CORBA_MODULE OBV_RTT
00326 _CORBA_MODULE_BEG
00327
00328 _CORBA_MODULE corba
00329 _CORBA_MODULE_BEG
00330
00331 _CORBA_MODULE_END
00332
00333 _CORBA_MODULE_END
00334
00335
00336
00337
00338
00339 #undef _core_attr
00340 #undef _dyn_attr
00341
00342 extern void operator<<=(::CORBA::Any& _a, const RTT::corba::Pair& _s);
00343 extern void operator<<=(::CORBA::Any& _a, RTT::corba::Pair* _sp);
00344 extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::Pair*& _sp);
00345 extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::Pair*& _sp);
00346
00347 void operator<<=(::CORBA::Any& _a, const RTT::corba::CAnySequence& _s);
00348 void operator<<=(::CORBA::Any& _a, RTT::corba::CAnySequence* _sp);
00349 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::CAnySequence*& _sp);
00350 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::CAnySequence*& _sp);
00351
00352 void operator<<=(::CORBA::Any& _a, const RTT::corba::PairSeq& _s);
00353 void operator<<=(::CORBA::Any& _a, RTT::corba::PairSeq* _sp);
00354 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, RTT::corba::PairSeq*& _sp);
00355 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const RTT::corba::PairSeq*& _sp);
00356
00357
00358
00359
00360
00361 #ifdef USE_stub_in_nt_dll_NOT_DEFINED_OrocosTypes
00362 # undef USE_stub_in_nt_dll
00363 # undef USE_stub_in_nt_dll_NOT_DEFINED_OrocosTypes
00364 #endif
00365 #ifdef USE_core_stub_in_nt_dll_NOT_DEFINED_OrocosTypes
00366 # undef USE_core_stub_in_nt_dll
00367 # undef USE_core_stub_in_nt_dll_NOT_DEFINED_OrocosTypes
00368 #endif
00369 #ifdef USE_dyn_stub_in_nt_dll_NOT_DEFINED_OrocosTypes
00370 # undef USE_dyn_stub_in_nt_dll
00371 # undef USE_dyn_stub_in_nt_dll_NOT_DEFINED_OrocosTypes
00372 #endif
00373
00374 #endif // __OrocosTypes_hh__
00375
