LogService
libdadi: utility tools for distributed applications
 All Classes Functions Variables
commonLogTypes.hh
00001 // This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
00002 #ifndef __commonLogTypes_hh__
00003 #define __commonLogTypes_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_commonLogTypes
00011 #endif
00012 #ifndef  USE_core_stub_in_nt_dll
00013 # define USE_core_stub_in_nt_dll_NOT_DEFINED_commonLogTypes
00014 #endif
00015 #ifndef  USE_dyn_stub_in_nt_dll
00016 # define USE_dyn_stub_in_nt_dll_NOT_DEFINED_commonLogTypes
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_GLOBAL_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_LogSeqAny;
00058 
00059 class LogSeqAny_var;
00060 
00061 class LogSeqAny : public _CORBA_Unbounded_Sequence< ::CORBA::Any >  {
00062 public:
00063   typedef LogSeqAny_var _var_type;
00064   inline LogSeqAny() {}
00065   inline LogSeqAny(const LogSeqAny& _s)
00066     : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_s) {}
00067 
00068   inline LogSeqAny(_CORBA_ULong _max)
00069     : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_max) {}
00070   inline LogSeqAny(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Any* _val, _CORBA_Boolean _rel=0)
00071     : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_max, _len, _val, _rel) {}
00072 
00073 
00074 
00075   inline LogSeqAny& operator = (const LogSeqAny& _s) {
00076     _CORBA_Unbounded_Sequence< ::CORBA::Any > ::operator=(_s);
00077     return *this;
00078   }
00079 };
00080 
00081 class LogSeqAny_out;
00082 
00083 class LogSeqAny_var {
00084 public:
00085   inline LogSeqAny_var() : _pd_seq(0) {}
00086   inline LogSeqAny_var(LogSeqAny* _s) : _pd_seq(_s) {}
00087   inline LogSeqAny_var(const LogSeqAny_var& _s) {
00088     if( _s._pd_seq )  _pd_seq = new LogSeqAny(*_s._pd_seq);
00089     else              _pd_seq = 0;
00090   }
00091   inline ~LogSeqAny_var() { if( _pd_seq )  delete _pd_seq; }
00092     
00093   inline LogSeqAny_var& operator = (LogSeqAny* _s) {
00094     if( _pd_seq )  delete _pd_seq;
00095     _pd_seq = _s;
00096     return *this;
00097   }
00098   inline LogSeqAny_var& operator = (const LogSeqAny_var& _s) {
00099     if( _s._pd_seq ) {
00100       if( !_pd_seq )  _pd_seq = new LogSeqAny;
00101       *_pd_seq = *_s._pd_seq;
00102     } else if( _pd_seq ) {
00103       delete _pd_seq;
00104       _pd_seq = 0;
00105     }
00106     return *this;
00107   }
00108   inline ::CORBA::Any& operator [] (_CORBA_ULong _s) {
00109     return (*_pd_seq)[_s];
00110   }
00111 
00112 
00113 
00114   inline LogSeqAny* operator -> () { return _pd_seq; }
00115   inline const LogSeqAny* operator -> () const { return _pd_seq; }
00116 #if defined(__GNUG__)
00117   inline operator LogSeqAny& () const { return *_pd_seq; }
00118 #else
00119   inline operator const LogSeqAny& () const { return *_pd_seq; }
00120   inline operator LogSeqAny& () { return *_pd_seq; }
00121 #endif
00122     
00123   inline const LogSeqAny& in() const { return *_pd_seq; }
00124   inline LogSeqAny&       inout()    { return *_pd_seq; }
00125   inline LogSeqAny*&      out() {
00126     if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
00127     return _pd_seq;
00128   }
00129   inline LogSeqAny* _retn() { LogSeqAny* tmp = _pd_seq; _pd_seq = 0; return tmp; }
00130     
00131   friend class LogSeqAny_out;
00132   
00133 private:
00134   LogSeqAny* _pd_seq;
00135 };
00136 
00137 class LogSeqAny_out {
00138 public:
00139   inline LogSeqAny_out(LogSeqAny*& _s) : _data(_s) { _data = 0; }
00140   inline LogSeqAny_out(LogSeqAny_var& _s)
00141     : _data(_s._pd_seq) { _s = (LogSeqAny*) 0; }
00142   inline LogSeqAny_out(const LogSeqAny_out& _s) : _data(_s._data) {}
00143   inline LogSeqAny_out& operator = (const LogSeqAny_out& _s) {
00144     _data = _s._data;
00145     return *this;
00146   }
00147   inline LogSeqAny_out& operator = (LogSeqAny* _s) {
00148     _data = _s;
00149     return *this;
00150   }
00151   inline operator LogSeqAny*&()  { return _data; }
00152   inline LogSeqAny*& ptr()       { return _data; }
00153   inline LogSeqAny* operator->() { return _data; }
00154 
00155   inline ::CORBA::Any& operator [] (_CORBA_ULong _i) {
00156     return (*_data)[_i];
00157   }
00158 
00159 
00160 
00161   LogSeqAny*& _data;
00162 
00163 private:
00164   LogSeqAny_out();
00165   LogSeqAny_out& operator=(const LogSeqAny_var&);
00166 };
00167 
00168 _CORBA_GLOBAL_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_LogSeqDouble;
00169 
00170 class LogSeqDouble_var;
00171 
00172 class LogSeqDouble : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 >  {
00173 public:
00174   typedef LogSeqDouble_var _var_type;
00175   inline LogSeqDouble() {}
00176   inline LogSeqDouble(const LogSeqDouble& _s)
00177     : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_s) {}
00178 
00179   inline LogSeqDouble(_CORBA_ULong _max)
00180     : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_max) {}
00181   inline LogSeqDouble(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Double* _val, _CORBA_Boolean _rel=0)
00182     : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_max, _len, _val, _rel) {}
00183 
00184 
00185 
00186   inline LogSeqDouble& operator = (const LogSeqDouble& _s) {
00187     _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > ::operator=(_s);
00188     return *this;
00189   }
00190 };
00191 
00192 class LogSeqDouble_out;
00193 
00194 class LogSeqDouble_var {
00195 public:
00196   inline LogSeqDouble_var() : _pd_seq(0) {}
00197   inline LogSeqDouble_var(LogSeqDouble* _s) : _pd_seq(_s) {}
00198   inline LogSeqDouble_var(const LogSeqDouble_var& _s) {
00199     if( _s._pd_seq )  _pd_seq = new LogSeqDouble(*_s._pd_seq);
00200     else              _pd_seq = 0;
00201   }
00202   inline ~LogSeqDouble_var() { if( _pd_seq )  delete _pd_seq; }
00203     
00204   inline LogSeqDouble_var& operator = (LogSeqDouble* _s) {
00205     if( _pd_seq )  delete _pd_seq;
00206     _pd_seq = _s;
00207     return *this;
00208   }
00209   inline LogSeqDouble_var& operator = (const LogSeqDouble_var& _s) {
00210     if( _s._pd_seq ) {
00211       if( !_pd_seq )  _pd_seq = new LogSeqDouble;
00212       *_pd_seq = *_s._pd_seq;
00213     } else if( _pd_seq ) {
00214       delete _pd_seq;
00215       _pd_seq = 0;
00216     }
00217     return *this;
00218   }
00219   inline ::CORBA::Double& operator [] (_CORBA_ULong _s) {
00220     return (*_pd_seq)[_s];
00221   }
00222 
00223 
00224 
00225   inline LogSeqDouble* operator -> () { return _pd_seq; }
00226   inline const LogSeqDouble* operator -> () const { return _pd_seq; }
00227 #if defined(__GNUG__)
00228   inline operator LogSeqDouble& () const { return *_pd_seq; }
00229 #else
00230   inline operator const LogSeqDouble& () const { return *_pd_seq; }
00231   inline operator LogSeqDouble& () { return *_pd_seq; }
00232 #endif
00233     
00234   inline const LogSeqDouble& in() const { return *_pd_seq; }
00235   inline LogSeqDouble&       inout()    { return *_pd_seq; }
00236   inline LogSeqDouble*&      out() {
00237     if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
00238     return _pd_seq;
00239   }
00240   inline LogSeqDouble* _retn() { LogSeqDouble* tmp = _pd_seq; _pd_seq = 0; return tmp; }
00241     
00242   friend class LogSeqDouble_out;
00243   
00244 private:
00245   LogSeqDouble* _pd_seq;
00246 };
00247 
00248 class LogSeqDouble_out {
00249 public:
00250   inline LogSeqDouble_out(LogSeqDouble*& _s) : _data(_s) { _data = 0; }
00251   inline LogSeqDouble_out(LogSeqDouble_var& _s)
00252     : _data(_s._pd_seq) { _s = (LogSeqDouble*) 0; }
00253   inline LogSeqDouble_out(const LogSeqDouble_out& _s) : _data(_s._data) {}
00254   inline LogSeqDouble_out& operator = (const LogSeqDouble_out& _s) {
00255     _data = _s._data;
00256     return *this;
00257   }
00258   inline LogSeqDouble_out& operator = (LogSeqDouble* _s) {
00259     _data = _s;
00260     return *this;
00261   }
00262   inline operator LogSeqDouble*&()  { return _data; }
00263   inline LogSeqDouble*& ptr()       { return _data; }
00264   inline LogSeqDouble* operator->() { return _data; }
00265 
00266   inline ::CORBA::Double& operator [] (_CORBA_ULong _i) {
00267     return (*_data)[_i];
00268   }
00269 
00270 
00271 
00272   LogSeqDouble*& _data;
00273 
00274 private:
00275   LogSeqDouble_out();
00276   LogSeqDouble_out& operator=(const LogSeqDouble_var&);
00277 };
00278 
00279 _CORBA_GLOBAL_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_LogSeqLong;
00280 
00281 class LogSeqLong_var;
00282 
00283 class LogSeqLong : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 >  {
00284 public:
00285   typedef LogSeqLong_var _var_type;
00286   inline LogSeqLong() {}
00287   inline LogSeqLong(const LogSeqLong& _s)
00288     : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_s) {}
00289 
00290   inline LogSeqLong(_CORBA_ULong _max)
00291     : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_max) {}
00292   inline LogSeqLong(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Long* _val, _CORBA_Boolean _rel=0)
00293     : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_max, _len, _val, _rel) {}
00294 
00295 
00296 
00297   inline LogSeqLong& operator = (const LogSeqLong& _s) {
00298     _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > ::operator=(_s);
00299     return *this;
00300   }
00301 };
00302 
00303 class LogSeqLong_out;
00304 
00305 class LogSeqLong_var {
00306 public:
00307   inline LogSeqLong_var() : _pd_seq(0) {}
00308   inline LogSeqLong_var(LogSeqLong* _s) : _pd_seq(_s) {}
00309   inline LogSeqLong_var(const LogSeqLong_var& _s) {
00310     if( _s._pd_seq )  _pd_seq = new LogSeqLong(*_s._pd_seq);
00311     else              _pd_seq = 0;
00312   }
00313   inline ~LogSeqLong_var() { if( _pd_seq )  delete _pd_seq; }
00314     
00315   inline LogSeqLong_var& operator = (LogSeqLong* _s) {
00316     if( _pd_seq )  delete _pd_seq;
00317     _pd_seq = _s;
00318     return *this;
00319   }
00320   inline LogSeqLong_var& operator = (const LogSeqLong_var& _s) {
00321     if( _s._pd_seq ) {
00322       if( !_pd_seq )  _pd_seq = new LogSeqLong;
00323       *_pd_seq = *_s._pd_seq;
00324     } else if( _pd_seq ) {
00325       delete _pd_seq;
00326       _pd_seq = 0;
00327     }
00328     return *this;
00329   }
00330   inline ::CORBA::Long& operator [] (_CORBA_ULong _s) {
00331     return (*_pd_seq)[_s];
00332   }
00333 
00334 
00335 
00336   inline LogSeqLong* operator -> () { return _pd_seq; }
00337   inline const LogSeqLong* operator -> () const { return _pd_seq; }
00338 #if defined(__GNUG__)
00339   inline operator LogSeqLong& () const { return *_pd_seq; }
00340 #else
00341   inline operator const LogSeqLong& () const { return *_pd_seq; }
00342   inline operator LogSeqLong& () { return *_pd_seq; }
00343 #endif
00344     
00345   inline const LogSeqLong& in() const { return *_pd_seq; }
00346   inline LogSeqLong&       inout()    { return *_pd_seq; }
00347   inline LogSeqLong*&      out() {
00348     if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
00349     return _pd_seq;
00350   }
00351   inline LogSeqLong* _retn() { LogSeqLong* tmp = _pd_seq; _pd_seq = 0; return tmp; }
00352     
00353   friend class LogSeqLong_out;
00354   
00355 private:
00356   LogSeqLong* _pd_seq;
00357 };
00358 
00359 class LogSeqLong_out {
00360 public:
00361   inline LogSeqLong_out(LogSeqLong*& _s) : _data(_s) { _data = 0; }
00362   inline LogSeqLong_out(LogSeqLong_var& _s)
00363     : _data(_s._pd_seq) { _s = (LogSeqLong*) 0; }
00364   inline LogSeqLong_out(const LogSeqLong_out& _s) : _data(_s._data) {}
00365   inline LogSeqLong_out& operator = (const LogSeqLong_out& _s) {
00366     _data = _s._data;
00367     return *this;
00368   }
00369   inline LogSeqLong_out& operator = (LogSeqLong* _s) {
00370     _data = _s;
00371     return *this;
00372   }
00373   inline operator LogSeqLong*&()  { return _data; }
00374   inline LogSeqLong*& ptr()       { return _data; }
00375   inline LogSeqLong* operator->() { return _data; }
00376 
00377   inline ::CORBA::Long& operator [] (_CORBA_ULong _i) {
00378     return (*_data)[_i];
00379   }
00380 
00381 
00382 
00383   LogSeqLong*& _data;
00384 
00385 private:
00386   LogSeqLong_out();
00387   LogSeqLong_out& operator=(const LogSeqLong_var&);
00388 };
00389 
00390 _CORBA_GLOBAL_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_LogSeqChar;
00391 
00392 class LogSeqChar_var;
00393 
00394 class LogSeqChar : public _CORBA_Unbounded_Sequence_Char {
00395 public:
00396   typedef LogSeqChar_var _var_type;
00397   inline LogSeqChar() {}
00398   inline LogSeqChar(const LogSeqChar& _s)
00399     : _CORBA_Unbounded_Sequence_Char(_s) {}
00400 
00401   inline LogSeqChar(_CORBA_ULong _max)
00402     : _CORBA_Unbounded_Sequence_Char(_max) {}
00403   inline LogSeqChar(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Char* _val, _CORBA_Boolean _rel=0)
00404     : _CORBA_Unbounded_Sequence_Char(_max, _len, _val, _rel) {}
00405 
00406 
00407 
00408   inline LogSeqChar& operator = (const LogSeqChar& _s) {
00409     _CORBA_Unbounded_Sequence_Char::operator=(_s);
00410     return *this;
00411   }
00412 };
00413 
00414 class LogSeqChar_out;
00415 
00416 class LogSeqChar_var {
00417 public:
00418   inline LogSeqChar_var() : _pd_seq(0) {}
00419   inline LogSeqChar_var(LogSeqChar* _s) : _pd_seq(_s) {}
00420   inline LogSeqChar_var(const LogSeqChar_var& _s) {
00421     if( _s._pd_seq )  _pd_seq = new LogSeqChar(*_s._pd_seq);
00422     else              _pd_seq = 0;
00423   }
00424   inline ~LogSeqChar_var() { if( _pd_seq )  delete _pd_seq; }
00425     
00426   inline LogSeqChar_var& operator = (LogSeqChar* _s) {
00427     if( _pd_seq )  delete _pd_seq;
00428     _pd_seq = _s;
00429     return *this;
00430   }
00431   inline LogSeqChar_var& operator = (const LogSeqChar_var& _s) {
00432     if( _s._pd_seq ) {
00433       if( !_pd_seq )  _pd_seq = new LogSeqChar;
00434       *_pd_seq = *_s._pd_seq;
00435     } else if( _pd_seq ) {
00436       delete _pd_seq;
00437       _pd_seq = 0;
00438     }
00439     return *this;
00440   }
00441   inline ::CORBA::Char& operator [] (_CORBA_ULong _s) {
00442     return (*_pd_seq)[_s];
00443   }
00444 
00445 
00446 
00447   inline LogSeqChar* operator -> () { return _pd_seq; }
00448   inline const LogSeqChar* operator -> () const { return _pd_seq; }
00449 #if defined(__GNUG__)
00450   inline operator LogSeqChar& () const { return *_pd_seq; }
00451 #else
00452   inline operator const LogSeqChar& () const { return *_pd_seq; }
00453   inline operator LogSeqChar& () { return *_pd_seq; }
00454 #endif
00455     
00456   inline const LogSeqChar& in() const { return *_pd_seq; }
00457   inline LogSeqChar&       inout()    { return *_pd_seq; }
00458   inline LogSeqChar*&      out() {
00459     if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
00460     return _pd_seq;
00461   }
00462   inline LogSeqChar* _retn() { LogSeqChar* tmp = _pd_seq; _pd_seq = 0; return tmp; }
00463     
00464   friend class LogSeqChar_out;
00465   
00466 private:
00467   LogSeqChar* _pd_seq;
00468 };
00469 
00470 class LogSeqChar_out {
00471 public:
00472   inline LogSeqChar_out(LogSeqChar*& _s) : _data(_s) { _data = 0; }
00473   inline LogSeqChar_out(LogSeqChar_var& _s)
00474     : _data(_s._pd_seq) { _s = (LogSeqChar*) 0; }
00475   inline LogSeqChar_out(const LogSeqChar_out& _s) : _data(_s._data) {}
00476   inline LogSeqChar_out& operator = (const LogSeqChar_out& _s) {
00477     _data = _s._data;
00478     return *this;
00479   }
00480   inline LogSeqChar_out& operator = (LogSeqChar* _s) {
00481     _data = _s;
00482     return *this;
00483   }
00484   inline operator LogSeqChar*&()  { return _data; }
00485   inline LogSeqChar*& ptr()       { return _data; }
00486   inline LogSeqChar* operator->() { return _data; }
00487 
00488   inline ::CORBA::Char& operator [] (_CORBA_ULong _i) {
00489     return (*_data)[_i];
00490   }
00491 
00492 
00493 
00494   LogSeqChar*& _data;
00495 
00496 private:
00497   LogSeqChar_out();
00498   LogSeqChar_out& operator=(const LogSeqChar_var&);
00499 };
00500 
00501 _CORBA_GLOBAL_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_LogSeqString;
00502 
00503 class LogSeqString_var;
00504 
00505 class LogSeqString : public _CORBA_Unbounded_Sequence_String {
00506 public:
00507   typedef LogSeqString_var _var_type;
00508   inline LogSeqString() {}
00509   inline LogSeqString(const LogSeqString& _s)
00510     : _CORBA_Unbounded_Sequence_String(_s) {}
00511 
00512   inline LogSeqString(_CORBA_ULong _max)
00513     : _CORBA_Unbounded_Sequence_String(_max) {}
00514   inline LogSeqString(_CORBA_ULong _max, _CORBA_ULong _len, char** _val, _CORBA_Boolean _rel=0)
00515     : _CORBA_Unbounded_Sequence_String(_max, _len, _val, _rel) {}
00516 
00517 
00518 
00519   inline LogSeqString& operator = (const LogSeqString& _s) {
00520     _CORBA_Unbounded_Sequence_String::operator=(_s);
00521     return *this;
00522   }
00523 };
00524 
00525 class LogSeqString_out;
00526 
00527 class LogSeqString_var {
00528 public:
00529   inline LogSeqString_var() : _pd_seq(0) {}
00530   inline LogSeqString_var(LogSeqString* _s) : _pd_seq(_s) {}
00531   inline LogSeqString_var(const LogSeqString_var& _s) {
00532     if( _s._pd_seq )  _pd_seq = new LogSeqString(*_s._pd_seq);
00533     else              _pd_seq = 0;
00534   }
00535   inline ~LogSeqString_var() { if( _pd_seq )  delete _pd_seq; }
00536     
00537   inline LogSeqString_var& operator = (LogSeqString* _s) {
00538     if( _pd_seq )  delete _pd_seq;
00539     _pd_seq = _s;
00540     return *this;
00541   }
00542   inline LogSeqString_var& operator = (const LogSeqString_var& _s) {
00543     if( _s._pd_seq ) {
00544       if( !_pd_seq )  _pd_seq = new LogSeqString;
00545       *_pd_seq = *_s._pd_seq;
00546     } else if( _pd_seq ) {
00547       delete _pd_seq;
00548       _pd_seq = 0;
00549     }
00550     return *this;
00551   }
00552   inline _CORBA_String_element operator [] (_CORBA_ULong _s) {
00553     return (*_pd_seq)[_s];
00554   }
00555 
00556 
00557 
00558   inline LogSeqString* operator -> () { return _pd_seq; }
00559   inline const LogSeqString* operator -> () const { return _pd_seq; }
00560 #if defined(__GNUG__)
00561   inline operator LogSeqString& () const { return *_pd_seq; }
00562 #else
00563   inline operator const LogSeqString& () const { return *_pd_seq; }
00564   inline operator LogSeqString& () { return *_pd_seq; }
00565 #endif
00566     
00567   inline const LogSeqString& in() const { return *_pd_seq; }
00568   inline LogSeqString&       inout()    { return *_pd_seq; }
00569   inline LogSeqString*&      out() {
00570     if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
00571     return _pd_seq;
00572   }
00573   inline LogSeqString* _retn() { LogSeqString* tmp = _pd_seq; _pd_seq = 0; return tmp; }
00574     
00575   friend class LogSeqString_out;
00576   
00577 private:
00578   LogSeqString* _pd_seq;
00579 };
00580 
00581 class LogSeqString_out {
00582 public:
00583   inline LogSeqString_out(LogSeqString*& _s) : _data(_s) { _data = 0; }
00584   inline LogSeqString_out(LogSeqString_var& _s)
00585     : _data(_s._pd_seq) { _s = (LogSeqString*) 0; }
00586   inline LogSeqString_out(const LogSeqString_out& _s) : _data(_s._data) {}
00587   inline LogSeqString_out& operator = (const LogSeqString_out& _s) {
00588     _data = _s._data;
00589     return *this;
00590   }
00591   inline LogSeqString_out& operator = (LogSeqString* _s) {
00592     _data = _s;
00593     return *this;
00594   }
00595   inline operator LogSeqString*&()  { return _data; }
00596   inline LogSeqString*& ptr()       { return _data; }
00597   inline LogSeqString* operator->() { return _data; }
00598 
00599   inline _CORBA_String_element operator [] (_CORBA_ULong _i) {
00600     return (*_data)[_i];
00601   }
00602 
00603 
00604 
00605   LogSeqString*& _data;
00606 
00607 private:
00608   LogSeqString_out();
00609   LogSeqString_out& operator=(const LogSeqString_var&);
00610 };
00611 
00612 class LogBadNameException : public ::CORBA::UserException {
00613 public:
00614   
00615   ::CORBA::String_member name;
00616 
00617   ::CORBA::String_member function;
00618 
00619   ::CORBA::String_member forwarder_name;
00620 
00621 
00622 
00623   inline LogBadNameException() {
00624     pd_insertToAnyFn    = insertToAnyFn;
00625     pd_insertToAnyFnNCP = insertToAnyFnNCP;
00626   }
00627   LogBadNameException(const LogBadNameException&);
00628   LogBadNameException(const char* i_name, const char* i_function, const char* i_forwarder_name);
00629   LogBadNameException& operator=(const LogBadNameException&);
00630   virtual ~LogBadNameException();
00631   virtual void _raise() const;
00632   static LogBadNameException* _downcast(::CORBA::Exception*);
00633   static const LogBadNameException* _downcast(const ::CORBA::Exception*);
00634   static inline LogBadNameException* _narrow(::CORBA::Exception* _e) {
00635     return _downcast(_e);
00636   }
00637   
00638   void operator>>=(cdrStream&) const ;
00639   void operator<<=(cdrStream&) ;
00640 
00641   static _core_attr insertExceptionToAny    insertToAnyFn;
00642   static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;
00643 
00644   virtual ::CORBA::Exception* _NP_duplicate() const;
00645 
00646   static _core_attr const char* _PD_repoId;
00647   static _core_attr const char* _PD_typeId;
00648 
00649 private:
00650   virtual const char* _NP_typeId() const;
00651   virtual const char* _NP_repoId(int*) const;
00652   virtual void _NP_marshal(cdrStream&) const;
00653 };
00654 
00655 _CORBA_GLOBAL_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_LogBadNameException;
00656 
00657 class LogUnknownObject : public ::CORBA::UserException {
00658 public:
00659   
00660   ::CORBA::String_member name;
00661 
00662 
00663 
00664   inline LogUnknownObject() {
00665     pd_insertToAnyFn    = insertToAnyFn;
00666     pd_insertToAnyFnNCP = insertToAnyFnNCP;
00667   }
00668   LogUnknownObject(const LogUnknownObject&);
00669   LogUnknownObject(const char* i_name);
00670   LogUnknownObject& operator=(const LogUnknownObject&);
00671   virtual ~LogUnknownObject();
00672   virtual void _raise() const;
00673   static LogUnknownObject* _downcast(::CORBA::Exception*);
00674   static const LogUnknownObject* _downcast(const ::CORBA::Exception*);
00675   static inline LogUnknownObject* _narrow(::CORBA::Exception* _e) {
00676     return _downcast(_e);
00677   }
00678   
00679   void operator>>=(cdrStream&) const ;
00680   void operator<<=(cdrStream&) ;
00681 
00682   static _core_attr insertExceptionToAny    insertToAnyFn;
00683   static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;
00684 
00685   virtual ::CORBA::Exception* _NP_duplicate() const;
00686 
00687   static _core_attr const char* _PD_repoId;
00688   static _core_attr const char* _PD_typeId;
00689 
00690 private:
00691   virtual const char* _NP_typeId() const;
00692   virtual const char* _NP_repoId(int*) const;
00693   virtual void _NP_marshal(cdrStream&) const;
00694 };
00695 
00696 _CORBA_GLOBAL_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_LogUnknownObject;
00697 
00698 
00699 
00700 
00701 
00702 
00703 
00704 
00705 
00706 #undef _core_attr
00707 #undef _dyn_attr
00708 
00709 void operator<<=(::CORBA::Any& _a, const LogSeqAny& _s);
00710 void operator<<=(::CORBA::Any& _a, LogSeqAny* _sp);
00711 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, LogSeqAny*& _sp);
00712 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const LogSeqAny*& _sp);
00713 
00714 void operator<<=(::CORBA::Any& _a, const LogSeqDouble& _s);
00715 void operator<<=(::CORBA::Any& _a, LogSeqDouble* _sp);
00716 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, LogSeqDouble*& _sp);
00717 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const LogSeqDouble*& _sp);
00718 
00719 void operator<<=(::CORBA::Any& _a, const LogSeqLong& _s);
00720 void operator<<=(::CORBA::Any& _a, LogSeqLong* _sp);
00721 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, LogSeqLong*& _sp);
00722 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const LogSeqLong*& _sp);
00723 
00724 void operator<<=(::CORBA::Any& _a, const LogSeqChar& _s);
00725 void operator<<=(::CORBA::Any& _a, LogSeqChar* _sp);
00726 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, LogSeqChar*& _sp);
00727 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const LogSeqChar*& _sp);
00728 
00729 void operator<<=(::CORBA::Any& _a, const LogSeqString& _s);
00730 void operator<<=(::CORBA::Any& _a, LogSeqString* _sp);
00731 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, LogSeqString*& _sp);
00732 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const LogSeqString*& _sp);
00733 
00734 void operator<<=(::CORBA::Any& _a, const LogBadNameException& _s);
00735 void operator<<=(::CORBA::Any& _a, const LogBadNameException* _sp);
00736 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const LogBadNameException*& _sp);
00737 
00738 void operator<<=(::CORBA::Any& _a, const LogUnknownObject& _s);
00739 void operator<<=(::CORBA::Any& _a, const LogUnknownObject* _sp);
00740 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const LogUnknownObject*& _sp);
00741 
00742 
00743 
00744 
00745 
00746 #ifdef   USE_stub_in_nt_dll_NOT_DEFINED_commonLogTypes
00747 # undef  USE_stub_in_nt_dll
00748 # undef  USE_stub_in_nt_dll_NOT_DEFINED_commonLogTypes
00749 #endif
00750 #ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_commonLogTypes
00751 # undef  USE_core_stub_in_nt_dll
00752 # undef  USE_core_stub_in_nt_dll_NOT_DEFINED_commonLogTypes
00753 #endif
00754 #ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_commonLogTypes
00755 # undef  USE_dyn_stub_in_nt_dll
00756 # undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_commonLogTypes
00757 #endif
00758 
00759 #endif  // __commonLogTypes_hh__
00760