liblogforwarderutils2-dev 2.7-1.1+b1 / usr / include / LogTypes.hh

// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __LogTypes_hh__
#define __LogTypes_hh__

#ifndef __CORBA_H_EXTERNAL_GUARD__
#include <omniORB4/CORBA.h>
#endif

#ifndef  USE_stub_in_nt_dll
# define USE_stub_in_nt_dll_NOT_DEFINED_LogTypes
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_LogTypes
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_LogTypes
#endif






#ifdef USE_stub_in_nt_dll
# ifndef USE_core_stub_in_nt_dll
#  define USE_core_stub_in_nt_dll
# endif
# ifndef USE_dyn_stub_in_nt_dll
#  define USE_dyn_stub_in_nt_dll
# endif
#endif

#ifdef _core_attr
# error "A local CPP macro _core_attr has already been defined."
#else
# ifdef  USE_core_stub_in_nt_dll
#  define _core_attr _OMNIORB_NTDLL_IMPORT
# else
#  define _core_attr
# endif
#endif

#ifdef _dyn_attr
# error "A local CPP macro _dyn_attr has already been defined."
#else
# ifdef  USE_dyn_stub_in_nt_dll
#  define _dyn_attr _OMNIORB_NTDLL_IMPORT
# else
#  define _dyn_attr
# endif
#endif





_CORBA_GLOBAL_VARINT const ::CORBA::Short LS_OK _init_in_decl_( = 0 );

struct log_time_t {
  typedef _CORBA_ConstrType_Fix_Var<log_time_t> _var_type;

  
  ::CORBA::Long sec;

  ::CORBA::Long msec;



  void operator>>= (cdrStream &) const;
  void operator<<= (cdrStream &);
};

typedef log_time_t::_var_type log_time_t_var;

typedef log_time_t& log_time_t_out;

_CORBA_GLOBAL_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_log_time_t;

struct log_msg_t {
  typedef _CORBA_ConstrType_Variable_Var<log_msg_t> _var_type;

  
  ::CORBA::String_member componentName;

  log_time_t time;

  ::CORBA::Boolean warning;

  ::CORBA::String_member tag;

  ::CORBA::String_member msg;



  void operator>>= (cdrStream &) const;
  void operator<<= (cdrStream &);
};

typedef log_msg_t::_var_type log_msg_t_var;

typedef _CORBA_ConstrType_Variable_OUT_arg< log_msg_t,log_msg_t_var > log_msg_t_out;

_CORBA_GLOBAL_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_log_msg_t;

_CORBA_GLOBAL_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_log_msg_buf_t;

class log_msg_buf_t_var;

class log_msg_buf_t : public _CORBA_Unbounded_Sequence< log_msg_t >  {
public:
  typedef log_msg_buf_t_var _var_type;
  inline log_msg_buf_t() {}
  inline log_msg_buf_t(const log_msg_buf_t& _s)
    : _CORBA_Unbounded_Sequence< log_msg_t > (_s) {}

  inline log_msg_buf_t(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence< log_msg_t > (_max) {}
  inline log_msg_buf_t(_CORBA_ULong _max, _CORBA_ULong _len, log_msg_t* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence< log_msg_t > (_max, _len, _val, _rel) {}



  inline log_msg_buf_t& operator = (const log_msg_buf_t& _s) {
    _CORBA_Unbounded_Sequence< log_msg_t > ::operator=(_s);
    return *this;
  }
};

class log_msg_buf_t_out;

class log_msg_buf_t_var {
public:
  inline log_msg_buf_t_var() : _pd_seq(0) {}
  inline log_msg_buf_t_var(log_msg_buf_t* _s) : _pd_seq(_s) {}
  inline log_msg_buf_t_var(const log_msg_buf_t_var& _s) {
    if( _s._pd_seq )  _pd_seq = new log_msg_buf_t(*_s._pd_seq);
    else              _pd_seq = 0;
  }
  inline ~log_msg_buf_t_var() { if( _pd_seq )  delete _pd_seq; }
    
  inline log_msg_buf_t_var& operator = (log_msg_buf_t* _s) {
    if( _pd_seq )  delete _pd_seq;
    _pd_seq = _s;
    return *this;
  }
  inline log_msg_buf_t_var& operator = (const log_msg_buf_t_var& _s) {
    if( _s._pd_seq ) {
      if( !_pd_seq )  _pd_seq = new log_msg_buf_t;
      *_pd_seq = *_s._pd_seq;
    } else if( _pd_seq ) {
      delete _pd_seq;
      _pd_seq = 0;
    }
    return *this;
  }
  inline log_msg_t& operator [] (_CORBA_ULong _s) {
    return (*_pd_seq)[_s];
  }



  inline log_msg_buf_t* operator -> () { return _pd_seq; }
  inline const log_msg_buf_t* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
  inline operator log_msg_buf_t& () const { return *_pd_seq; }
#else
  inline operator const log_msg_buf_t& () const { return *_pd_seq; }
  inline operator log_msg_buf_t& () { return *_pd_seq; }
#endif
    
  inline const log_msg_buf_t& in() const { return *_pd_seq; }
  inline log_msg_buf_t&       inout()    { return *_pd_seq; }
  inline log_msg_buf_t*&      out() {
    if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
    return _pd_seq;
  }
  inline log_msg_buf_t* _retn() { log_msg_buf_t* tmp = _pd_seq; _pd_seq = 0; return tmp; }
    
  friend class log_msg_buf_t_out;
  
private:
  log_msg_buf_t* _pd_seq;
};

class log_msg_buf_t_out {
public:
  inline log_msg_buf_t_out(log_msg_buf_t*& _s) : _data(_s) { _data = 0; }
  inline log_msg_buf_t_out(log_msg_buf_t_var& _s)
    : _data(_s._pd_seq) { _s = (log_msg_buf_t*) 0; }
  inline log_msg_buf_t_out(const log_msg_buf_t_out& _s) : _data(_s._data) {}
  inline log_msg_buf_t_out& operator = (const log_msg_buf_t_out& _s) {
    _data = _s._data;
    return *this;
  }
  inline log_msg_buf_t_out& operator = (log_msg_buf_t* _s) {
    _data = _s;
    return *this;
  }
  inline operator log_msg_buf_t*&()  { return _data; }
  inline log_msg_buf_t*& ptr()       { return _data; }
  inline log_msg_buf_t* operator->() { return _data; }

  inline log_msg_t& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  log_msg_buf_t*& _data;

private:
  log_msg_buf_t_out();
  log_msg_buf_t_out& operator=(const log_msg_buf_t_var&);
};

_CORBA_GLOBAL_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_tag_list_t;

class tag_list_t_var;

class tag_list_t : public _CORBA_Unbounded_Sequence_String {
public:
  typedef tag_list_t_var _var_type;
  inline tag_list_t() {}
  inline tag_list_t(const tag_list_t& _s)
    : _CORBA_Unbounded_Sequence_String(_s) {}

  inline tag_list_t(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_String(_max) {}
  inline tag_list_t(_CORBA_ULong _max, _CORBA_ULong _len, char** _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_String(_max, _len, _val, _rel) {}



  inline tag_list_t& operator = (const tag_list_t& _s) {
    _CORBA_Unbounded_Sequence_String::operator=(_s);
    return *this;
  }
};

class tag_list_t_out;

class tag_list_t_var {
public:
  inline tag_list_t_var() : _pd_seq(0) {}
  inline tag_list_t_var(tag_list_t* _s) : _pd_seq(_s) {}
  inline tag_list_t_var(const tag_list_t_var& _s) {
    if( _s._pd_seq )  _pd_seq = new tag_list_t(*_s._pd_seq);
    else              _pd_seq = 0;
  }
  inline ~tag_list_t_var() { if( _pd_seq )  delete _pd_seq; }
    
  inline tag_list_t_var& operator = (tag_list_t* _s) {
    if( _pd_seq )  delete _pd_seq;
    _pd_seq = _s;
    return *this;
  }
  inline tag_list_t_var& operator = (const tag_list_t_var& _s) {
    if( _s._pd_seq ) {
      if( !_pd_seq )  _pd_seq = new tag_list_t;
      *_pd_seq = *_s._pd_seq;
    } else if( _pd_seq ) {
      delete _pd_seq;
      _pd_seq = 0;
    }
    return *this;
  }
  inline _CORBA_String_element operator [] (_CORBA_ULong _s) {
    return (*_pd_seq)[_s];
  }



  inline tag_list_t* operator -> () { return _pd_seq; }
  inline const tag_list_t* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
  inline operator tag_list_t& () const { return *_pd_seq; }
#else
  inline operator const tag_list_t& () const { return *_pd_seq; }
  inline operator tag_list_t& () { return *_pd_seq; }
#endif
    
  inline const tag_list_t& in() const { return *_pd_seq; }
  inline tag_list_t&       inout()    { return *_pd_seq; }
  inline tag_list_t*&      out() {
    if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
    return _pd_seq;
  }
  inline tag_list_t* _retn() { tag_list_t* tmp = _pd_seq; _pd_seq = 0; return tmp; }
    
  friend class tag_list_t_out;
  
private:
  tag_list_t* _pd_seq;
};

class tag_list_t_out {
public:
  inline tag_list_t_out(tag_list_t*& _s) : _data(_s) { _data = 0; }
  inline tag_list_t_out(tag_list_t_var& _s)
    : _data(_s._pd_seq) { _s = (tag_list_t*) 0; }
  inline tag_list_t_out(const tag_list_t_out& _s) : _data(_s._data) {}
  inline tag_list_t_out& operator = (const tag_list_t_out& _s) {
    _data = _s._data;
    return *this;
  }
  inline tag_list_t_out& operator = (tag_list_t* _s) {
    _data = _s;
    return *this;
  }
  inline operator tag_list_t*&()  { return _data; }
  inline tag_list_t*& ptr()       { return _data; }
  inline tag_list_t* operator->() { return _data; }

  inline _CORBA_String_element operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  tag_list_t*& _data;

private:
  tag_list_t_out();
  tag_list_t_out& operator=(const tag_list_t_var&);
};

_CORBA_GLOBAL_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_component_list_t;

class component_list_t_var;

class component_list_t : public _CORBA_Unbounded_Sequence_String {
public:
  typedef component_list_t_var _var_type;
  inline component_list_t() {}
  inline component_list_t(const component_list_t& _s)
    : _CORBA_Unbounded_Sequence_String(_s) {}

  inline component_list_t(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_String(_max) {}
  inline component_list_t(_CORBA_ULong _max, _CORBA_ULong _len, char** _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_String(_max, _len, _val, _rel) {}



  inline component_list_t& operator = (const component_list_t& _s) {
    _CORBA_Unbounded_Sequence_String::operator=(_s);
    return *this;
  }
};

class component_list_t_out;

class component_list_t_var {
public:
  inline component_list_t_var() : _pd_seq(0) {}
  inline component_list_t_var(component_list_t* _s) : _pd_seq(_s) {}
  inline component_list_t_var(const component_list_t_var& _s) {
    if( _s._pd_seq )  _pd_seq = new component_list_t(*_s._pd_seq);
    else              _pd_seq = 0;
  }
  inline ~component_list_t_var() { if( _pd_seq )  delete _pd_seq; }
    
  inline component_list_t_var& operator = (component_list_t* _s) {
    if( _pd_seq )  delete _pd_seq;
    _pd_seq = _s;
    return *this;
  }
  inline component_list_t_var& operator = (const component_list_t_var& _s) {
    if( _s._pd_seq ) {
      if( !_pd_seq )  _pd_seq = new component_list_t;
      *_pd_seq = *_s._pd_seq;
    } else if( _pd_seq ) {
      delete _pd_seq;
      _pd_seq = 0;
    }
    return *this;
  }
  inline _CORBA_String_element operator [] (_CORBA_ULong _s) {
    return (*_pd_seq)[_s];
  }



  inline component_list_t* operator -> () { return _pd_seq; }
  inline const component_list_t* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
  inline operator component_list_t& () const { return *_pd_seq; }
#else
  inline operator const component_list_t& () const { return *_pd_seq; }
  inline operator component_list_t& () { return *_pd_seq; }
#endif
    
  inline const component_list_t& in() const { return *_pd_seq; }
  inline component_list_t&       inout()    { return *_pd_seq; }
  inline component_list_t*&      out() {
    if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
    return _pd_seq;
  }
  inline component_list_t* _retn() { component_list_t* tmp = _pd_seq; _pd_seq = 0; return tmp; }
    
  friend class component_list_t_out;
  
private:
  component_list_t* _pd_seq;
};

class component_list_t_out {
public:
  inline component_list_t_out(component_list_t*& _s) : _data(_s) { _data = 0; }
  inline component_list_t_out(component_list_t_var& _s)
    : _data(_s._pd_seq) { _s = (component_list_t*) 0; }
  inline component_list_t_out(const component_list_t_out& _s) : _data(_s._data) {}
  inline component_list_t_out& operator = (const component_list_t_out& _s) {
    _data = _s._data;
    return *this;
  }
  inline component_list_t_out& operator = (component_list_t* _s) {
    _data = _s;
    return *this;
  }
  inline operator component_list_t*&()  { return _data; }
  inline component_list_t*& ptr()       { return _data; }
  inline component_list_t* operator->() { return _data; }

  inline _CORBA_String_element operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  component_list_t*& _data;

private:
  component_list_t_out();
  component_list_t_out& operator=(const component_list_t_var&);
};









#undef _core_attr
#undef _dyn_attr

extern void operator<<=(::CORBA::Any& _a, const log_time_t& _s);
extern void operator<<=(::CORBA::Any& _a, log_time_t* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, log_time_t*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const log_time_t*& _sp);

extern void operator<<=(::CORBA::Any& _a, const log_msg_t& _s);
extern void operator<<=(::CORBA::Any& _a, log_msg_t* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, log_msg_t*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const log_msg_t*& _sp);

void operator<<=(::CORBA::Any& _a, const log_msg_buf_t& _s);
void operator<<=(::CORBA::Any& _a, log_msg_buf_t* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, log_msg_buf_t*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const log_msg_buf_t*& _sp);

void operator<<=(::CORBA::Any& _a, const tag_list_t& _s);
void operator<<=(::CORBA::Any& _a, tag_list_t* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, tag_list_t*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const tag_list_t*& _sp);

void operator<<=(::CORBA::Any& _a, const component_list_t& _s);
void operator<<=(::CORBA::Any& _a, component_list_t* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, component_list_t*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const component_list_t*& _sp);





#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_LogTypes
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_LogTypes
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_LogTypes
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_LogTypes
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_LogTypes
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_LogTypes
#endif

#endif  // __LogTypes_hh__