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

#ifndef __CORBA_mIDLType__
#define __CORBA_mIDLType__
class IDLType;
class _objref_IDLType;
class _impl_IDLType;

typedef _objref_IDLType* IDLType_ptr;
typedef IDLType_ptr IDLTypeRef;

class IDLType_Helper {
public:
  typedef IDLType_ptr _ptr_type;

  static _ptr_type _nil();
  static _CORBA_Boolean is_nil(_ptr_type);
  static void release(_ptr_type);
  static void duplicate(_ptr_type);
  static void marshalObjRef(_ptr_type, cdrStream&);
  static _ptr_type unmarshalObjRef(cdrStream&);
};

typedef _CORBA_ObjRef_Var<_objref_IDLType, IDLType_Helper> IDLType_var;
typedef _CORBA_ObjRef_OUT_arg<_objref_IDLType,IDLType_Helper > IDLType_out;

#endif

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Identifier;

typedef char* Identifier;
typedef ::CORBA::String_var Identifier_var;
typedef ::CORBA::String_out Identifier_out;

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_RepositoryId;

typedef char* RepositoryId;
typedef ::CORBA::String_var RepositoryId_var;
typedef ::CORBA::String_out RepositoryId_out;

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_VersionSpec;

typedef char* VersionSpec;
typedef ::CORBA::String_var VersionSpec_var;
typedef ::CORBA::String_out VersionSpec_out;

struct StructMember {
  typedef _CORBA_ConstrType_Variable_Var<StructMember> _var_type;

  
  ::CORBA::String_member name;

  ::CORBA::TypeCode_member type;

  _CORBA_ObjRef_Member< _objref_IDLType, IDLType_Helper>  type_def;



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

typedef StructMember::_var_type StructMember_var;

typedef _CORBA_ConstrType_Variable_OUT_arg< StructMember,StructMember_var > StructMember_out;

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_StructMember;

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_StructMemberSeq;

class StructMemberSeq_var;

class StructMemberSeq : public _CORBA_Unbounded_Sequence< StructMember >  {
public:
  typedef StructMemberSeq_var _var_type;
  inline StructMemberSeq() {}
  inline StructMemberSeq(const StructMemberSeq& _s)
    : _CORBA_Unbounded_Sequence< StructMember > (_s) {}

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



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

class StructMemberSeq_out;

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



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

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

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



  StructMemberSeq*& _data;

private:
  StructMemberSeq_out();
  StructMemberSeq_out& operator=(const StructMemberSeq_var&);
};

struct UnionMember {
  typedef _CORBA_ConstrType_Variable_Var<UnionMember> _var_type;

  
  ::CORBA::String_member name;

  ::CORBA::Any label;

  ::CORBA::TypeCode_member type;

  _CORBA_ObjRef_Member< _objref_IDLType, IDLType_Helper>  type_def;



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

typedef UnionMember::_var_type UnionMember_var;

typedef _CORBA_ConstrType_Variable_OUT_arg< UnionMember,UnionMember_var > UnionMember_out;

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_UnionMember;

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_UnionMemberSeq;

class UnionMemberSeq_var;

class UnionMemberSeq : public _CORBA_Unbounded_Sequence< UnionMember >  {
public:
  typedef UnionMemberSeq_var _var_type;
  inline UnionMemberSeq() {}
  inline UnionMemberSeq(const UnionMemberSeq& _s)
    : _CORBA_Unbounded_Sequence< UnionMember > (_s) {}

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



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

class UnionMemberSeq_out;

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



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

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

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



  UnionMemberSeq*& _data;

private:
  UnionMemberSeq_out();
  UnionMemberSeq_out& operator=(const UnionMemberSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_EnumMemberSeq;

class EnumMemberSeq_var;

class EnumMemberSeq : public _CORBA_Unbounded_Sequence_String {
public:
  typedef EnumMemberSeq_var _var_type;
  inline EnumMemberSeq() {}
  inline EnumMemberSeq(const EnumMemberSeq& _s)
    : _CORBA_Unbounded_Sequence_String(_s) {}

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



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

class EnumMemberSeq_out;

class EnumMemberSeq_var {
public:
  inline EnumMemberSeq_var() : _pd_seq(0) {}
  inline EnumMemberSeq_var(EnumMemberSeq* _s) : _pd_seq(_s) {}
  inline EnumMemberSeq_var(const EnumMemberSeq_var& _s) {
    if (_s._pd_seq)  _pd_seq = new EnumMemberSeq(*_s._pd_seq);
    else             _pd_seq = 0;
  }
  inline ~EnumMemberSeq_var() { if (_pd_seq)  delete _pd_seq; }
    
  inline EnumMemberSeq_var& operator = (EnumMemberSeq* _s) {
    if (_pd_seq)  delete _pd_seq;
    _pd_seq = _s;
    return *this;
  }
  inline EnumMemberSeq_var& operator = (const EnumMemberSeq_var& _s) {
    if (&_s != this) {
      if (_s._pd_seq) {
        if (!_pd_seq)  _pd_seq = new EnumMemberSeq;
        *_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 EnumMemberSeq* operator -> () { return _pd_seq; }
  inline const EnumMemberSeq* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
  inline operator EnumMemberSeq& () const { return *_pd_seq; }
#else
  inline operator const EnumMemberSeq& () const { return *_pd_seq; }
  inline operator EnumMemberSeq& () { return *_pd_seq; }
#endif
    
  inline const EnumMemberSeq& in() const { return *_pd_seq; }
  inline EnumMemberSeq&       inout()    { return *_pd_seq; }
  inline EnumMemberSeq*&      out() {
    if (_pd_seq) { delete _pd_seq; _pd_seq = 0; }
    return _pd_seq;
  }
  inline EnumMemberSeq* _retn() { EnumMemberSeq* tmp = _pd_seq; _pd_seq = 0; return tmp; }
    
  friend class EnumMemberSeq_out;
  
private:
  EnumMemberSeq* _pd_seq;
};

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

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



  EnumMemberSeq*& _data;

private:
  EnumMemberSeq_out();
  EnumMemberSeq_out& operator=(const EnumMemberSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Visibility;

typedef ::CORBA::Short Visibility;
typedef ::CORBA::Short_out Visibility_out;

_CORBA_MODULE_VARINT const ::CORBA::Short PRIVATE_MEMBER _init_in_decl_( = 0 );

_CORBA_MODULE_VARINT const ::CORBA::Short PUBLIC_MEMBER _init_in_decl_( = 1 );

struct ValueMember {
  typedef _CORBA_ConstrType_Variable_Var<ValueMember> _var_type;

  
  ::CORBA::String_member name;

  ::CORBA::String_member id;

  ::CORBA::String_member defined_in;

  ::CORBA::String_member version;

  ::CORBA::TypeCode_member type;

  _CORBA_ObjRef_Member< _objref_IDLType, IDLType_Helper>  type_def;

  Visibility access;



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

typedef ValueMember::_var_type ValueMember_var;

typedef _CORBA_ConstrType_Variable_OUT_arg< ValueMember,ValueMember_var > ValueMember_out;

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ValueMember;

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ValueMemberSeq;

class ValueMemberSeq_var;

class ValueMemberSeq : public _CORBA_Unbounded_Sequence< ValueMember >  {
public:
  typedef ValueMemberSeq_var _var_type;
  inline ValueMemberSeq() {}
  inline ValueMemberSeq(const ValueMemberSeq& _s)
    : _CORBA_Unbounded_Sequence< ValueMember > (_s) {}

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



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

class ValueMemberSeq_out;

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



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

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

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



  ValueMemberSeq*& _data;

private:
  ValueMemberSeq_out();
  ValueMemberSeq_out& operator=(const ValueMemberSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AnySeq;

class AnySeq_var;

class AnySeq : public _CORBA_Unbounded_Sequence< ::CORBA::Any >  {
public:
  typedef AnySeq_var _var_type;
  inline AnySeq() {}
  inline AnySeq(const AnySeq& _s)
    : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_s) {}

  inline AnySeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_max) {}
  inline AnySeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Any* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence< ::CORBA::Any > (_max, _len, _val, _rel) {}



  inline AnySeq& operator = (const AnySeq& _s) {
    _CORBA_Unbounded_Sequence< ::CORBA::Any > ::operator=(_s);
    return *this;
  }
};

class AnySeq_out;

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



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

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

  inline ::CORBA::Any& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  AnySeq*& _data;

private:
  AnySeq_out();
  AnySeq_out& operator=(const AnySeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_BooleanSeq;

class BooleanSeq_var;

class BooleanSeq : public _CORBA_Unbounded_Sequence_Boolean {
public:
  typedef BooleanSeq_var _var_type;
  inline BooleanSeq() {}
  inline BooleanSeq(const BooleanSeq& _s)
    : _CORBA_Unbounded_Sequence_Boolean(_s) {}

  inline BooleanSeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_Boolean(_max) {}
  inline BooleanSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Boolean* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_Boolean(_max, _len, _val, _rel) {}



  inline BooleanSeq& operator = (const BooleanSeq& _s) {
    _CORBA_Unbounded_Sequence_Boolean::operator=(_s);
    return *this;
  }
};

class BooleanSeq_out;

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



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

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

  inline ::CORBA::Boolean& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  BooleanSeq*& _data;

private:
  BooleanSeq_out();
  BooleanSeq_out& operator=(const BooleanSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CharSeq;

class CharSeq_var;

class CharSeq : public _CORBA_Unbounded_Sequence_Char {
public:
  typedef CharSeq_var _var_type;
  inline CharSeq() {}
  inline CharSeq(const CharSeq& _s)
    : _CORBA_Unbounded_Sequence_Char(_s) {}

  inline CharSeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_Char(_max) {}
  inline CharSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Char* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_Char(_max, _len, _val, _rel) {}



  inline CharSeq& operator = (const CharSeq& _s) {
    _CORBA_Unbounded_Sequence_Char::operator=(_s);
    return *this;
  }
};

class CharSeq_out;

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



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

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

  inline ::CORBA::Char& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  CharSeq*& _data;

private:
  CharSeq_out();
  CharSeq_out& operator=(const CharSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_WCharSeq;

class WCharSeq_var;

class WCharSeq : public _CORBA_Unbounded_Sequence_WChar {
public:
  typedef WCharSeq_var _var_type;
  inline WCharSeq() {}
  inline WCharSeq(const WCharSeq& _s)
    : _CORBA_Unbounded_Sequence_WChar(_s) {}

  inline WCharSeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_WChar(_max) {}
  inline WCharSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::WChar* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_WChar(_max, _len, _val, _rel) {}



  inline WCharSeq& operator = (const WCharSeq& _s) {
    _CORBA_Unbounded_Sequence_WChar::operator=(_s);
    return *this;
  }
};

class WCharSeq_out;

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



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

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

  inline ::CORBA::WChar& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  WCharSeq*& _data;

private:
  WCharSeq_out();
  WCharSeq_out& operator=(const WCharSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_OctetSeq;

class OctetSeq_var;

class OctetSeq : public _CORBA_Unbounded_Sequence_Octet {
public:
  typedef OctetSeq_var _var_type;
  inline OctetSeq() {}
  inline OctetSeq(const OctetSeq& _s)
    : _CORBA_Unbounded_Sequence_Octet(_s) {}

  inline OctetSeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_Octet(_max) {}
  inline OctetSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Octet* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_Octet(_max, _len, _val, _rel) {}



  inline OctetSeq& operator = (const OctetSeq& _s) {
    _CORBA_Unbounded_Sequence_Octet::operator=(_s);
    return *this;
  }
};

class OctetSeq_out;

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



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

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

  inline ::CORBA::Octet& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  OctetSeq*& _data;

private:
  OctetSeq_out();
  OctetSeq_out& operator=(const OctetSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ShortSeq;

class ShortSeq_var;

class ShortSeq : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Short, 2, 2 >  {
public:
  typedef ShortSeq_var _var_type;
  inline ShortSeq() {}
  inline ShortSeq(const ShortSeq& _s)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Short, 2, 2 > (_s) {}

  inline ShortSeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Short, 2, 2 > (_max) {}
  inline ShortSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Short* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Short, 2, 2 > (_max, _len, _val, _rel) {}



  inline ShortSeq& operator = (const ShortSeq& _s) {
    _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Short, 2, 2 > ::operator=(_s);
    return *this;
  }
};

class ShortSeq_out;

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



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

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

  inline ::CORBA::Short& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  ShortSeq*& _data;

private:
  ShortSeq_out();
  ShortSeq_out& operator=(const ShortSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_UShortSeq;

class UShortSeq_var;

class UShortSeq : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::UShort, 2, 2 >  {
public:
  typedef UShortSeq_var _var_type;
  inline UShortSeq() {}
  inline UShortSeq(const UShortSeq& _s)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::UShort, 2, 2 > (_s) {}

  inline UShortSeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::UShort, 2, 2 > (_max) {}
  inline UShortSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::UShort* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::UShort, 2, 2 > (_max, _len, _val, _rel) {}



  inline UShortSeq& operator = (const UShortSeq& _s) {
    _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::UShort, 2, 2 > ::operator=(_s);
    return *this;
  }
};

class UShortSeq_out;

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



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

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

  inline ::CORBA::UShort& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  UShortSeq*& _data;

private:
  UShortSeq_out();
  UShortSeq_out& operator=(const UShortSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_LongSeq;

class LongSeq_var;

class LongSeq : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 >  {
public:
  typedef LongSeq_var _var_type;
  inline LongSeq() {}
  inline LongSeq(const LongSeq& _s)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_s) {}

  inline LongSeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_max) {}
  inline LongSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Long* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_max, _len, _val, _rel) {}



  inline LongSeq& operator = (const LongSeq& _s) {
    _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > ::operator=(_s);
    return *this;
  }
};

class LongSeq_out;

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



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

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

  inline ::CORBA::Long& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  LongSeq*& _data;

private:
  LongSeq_out();
  LongSeq_out& operator=(const LongSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ULongSeq;

class ULongSeq_var;

class ULongSeq : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULong, 4, 4 >  {
public:
  typedef ULongSeq_var _var_type;
  inline ULongSeq() {}
  inline ULongSeq(const ULongSeq& _s)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULong, 4, 4 > (_s) {}

  inline ULongSeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULong, 4, 4 > (_max) {}
  inline ULongSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::ULong* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULong, 4, 4 > (_max, _len, _val, _rel) {}



  inline ULongSeq& operator = (const ULongSeq& _s) {
    _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULong, 4, 4 > ::operator=(_s);
    return *this;
  }
};

class ULongSeq_out;

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



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

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

  inline ::CORBA::ULong& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  ULongSeq*& _data;

private:
  ULongSeq_out();
  ULongSeq_out& operator=(const ULongSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_LongLongSeq;

class LongLongSeq_var;

class LongLongSeq : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 >  {
public:
  typedef LongLongSeq_var _var_type;
  inline LongLongSeq() {}
  inline LongLongSeq(const LongLongSeq& _s)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 > (_s) {}

  inline LongLongSeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 > (_max) {}
  inline LongLongSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::LongLong* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 > (_max, _len, _val, _rel) {}



  inline LongLongSeq& operator = (const LongLongSeq& _s) {
    _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 > ::operator=(_s);
    return *this;
  }
};

class LongLongSeq_out;

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



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

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

  inline ::CORBA::LongLong& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  LongLongSeq*& _data;

private:
  LongLongSeq_out();
  LongLongSeq_out& operator=(const LongLongSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ULongLongSeq;

class ULongLongSeq_var;

class ULongLongSeq : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULongLong, 8, 8 >  {
public:
  typedef ULongLongSeq_var _var_type;
  inline ULongLongSeq() {}
  inline ULongLongSeq(const ULongLongSeq& _s)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULongLong, 8, 8 > (_s) {}

  inline ULongLongSeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULongLong, 8, 8 > (_max) {}
  inline ULongLongSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::ULongLong* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULongLong, 8, 8 > (_max, _len, _val, _rel) {}



  inline ULongLongSeq& operator = (const ULongLongSeq& _s) {
    _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULongLong, 8, 8 > ::operator=(_s);
    return *this;
  }
};

class ULongLongSeq_out;

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



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

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

  inline ::CORBA::ULongLong& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  ULongLongSeq*& _data;

private:
  ULongLongSeq_out();
  ULongLongSeq_out& operator=(const ULongLongSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_FloatSeq;

class FloatSeq_var;

class FloatSeq : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 >  {
public:
  typedef FloatSeq_var _var_type;
  inline FloatSeq() {}
  inline FloatSeq(const FloatSeq& _s)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 > (_s) {}

  inline FloatSeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 > (_max) {}
  inline FloatSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Float* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 > (_max, _len, _val, _rel) {}



  inline FloatSeq& operator = (const FloatSeq& _s) {
    _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 > ::operator=(_s);
    return *this;
  }
};

class FloatSeq_out;

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



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

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

  inline ::CORBA::Float& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  FloatSeq*& _data;

private:
  FloatSeq_out();
  FloatSeq_out& operator=(const FloatSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DoubleSeq;

class DoubleSeq_var;

class DoubleSeq : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 >  {
public:
  typedef DoubleSeq_var _var_type;
  inline DoubleSeq() {}
  inline DoubleSeq(const DoubleSeq& _s)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_s) {}

  inline DoubleSeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_max) {}
  inline DoubleSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Double* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_max, _len, _val, _rel) {}



  inline DoubleSeq& operator = (const DoubleSeq& _s) {
    _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > ::operator=(_s);
    return *this;
  }
};

class DoubleSeq_out;

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



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

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

  inline ::CORBA::Double& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  DoubleSeq*& _data;

private:
  DoubleSeq_out();
  DoubleSeq_out& operator=(const DoubleSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_LongDoubleSeq;

class LongDoubleSeq_var;

class LongDoubleSeq : public _CORBA_Unbounded_Sequence< ::CORBA::LongDouble >  {
public:
  typedef LongDoubleSeq_var _var_type;
  inline LongDoubleSeq() {}
  inline LongDoubleSeq(const LongDoubleSeq& _s)
    : _CORBA_Unbounded_Sequence< ::CORBA::LongDouble > (_s) {}

  inline LongDoubleSeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence< ::CORBA::LongDouble > (_max) {}
  inline LongDoubleSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::LongDouble* _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence< ::CORBA::LongDouble > (_max, _len, _val, _rel) {}



  inline LongDoubleSeq& operator = (const LongDoubleSeq& _s) {
    _CORBA_Unbounded_Sequence< ::CORBA::LongDouble > ::operator=(_s);
    return *this;
  }
};

class LongDoubleSeq_out;

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



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

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

  inline ::CORBA::LongDouble& operator [] (_CORBA_ULong _i) {
    return (*_data)[_i];
  }



  LongDoubleSeq*& _data;

private:
  LongDoubleSeq_out();
  LongDoubleSeq_out& operator=(const LongDoubleSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_StringSeq;

class StringSeq_var;

class StringSeq : public _CORBA_Unbounded_Sequence_String {
public:
  typedef StringSeq_var _var_type;
  inline StringSeq() {}
  inline StringSeq(const StringSeq& _s)
    : _CORBA_Unbounded_Sequence_String(_s) {}

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



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

class StringSeq_out;

class StringSeq_var {
public:
  inline StringSeq_var() : _pd_seq(0) {}
  inline StringSeq_var(StringSeq* _s) : _pd_seq(_s) {}
  inline StringSeq_var(const StringSeq_var& _s) {
    if (_s._pd_seq)  _pd_seq = new StringSeq(*_s._pd_seq);
    else             _pd_seq = 0;
  }
  inline ~StringSeq_var() { if (_pd_seq)  delete _pd_seq; }
    
  inline StringSeq_var& operator = (StringSeq* _s) {
    if (_pd_seq)  delete _pd_seq;
    _pd_seq = _s;
    return *this;
  }
  inline StringSeq_var& operator = (const StringSeq_var& _s) {
    if (&_s != this) {
      if (_s._pd_seq) {
        if (!_pd_seq)  _pd_seq = new StringSeq;
        *_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 StringSeq* operator -> () { return _pd_seq; }
  inline const StringSeq* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
  inline operator StringSeq& () const { return *_pd_seq; }
#else
  inline operator const StringSeq& () const { return *_pd_seq; }
  inline operator StringSeq& () { return *_pd_seq; }
#endif
    
  inline const StringSeq& in() const { return *_pd_seq; }
  inline StringSeq&       inout()    { return *_pd_seq; }
  inline StringSeq*&      out() {
    if (_pd_seq) { delete _pd_seq; _pd_seq = 0; }
    return _pd_seq;
  }
  inline StringSeq* _retn() { StringSeq* tmp = _pd_seq; _pd_seq = 0; return tmp; }
    
  friend class StringSeq_out;
  
private:
  StringSeq* _pd_seq;
};

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

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



  StringSeq*& _data;

private:
  StringSeq_out();
  StringSeq_out& operator=(const StringSeq_var&);
};

_CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_WStringSeq;

class WStringSeq_var;

class WStringSeq : public _CORBA_Unbounded_Sequence_WString {
public:
  typedef WStringSeq_var _var_type;
  inline WStringSeq() {}
  inline WStringSeq(const WStringSeq& _s)
    : _CORBA_Unbounded_Sequence_WString(_s) {}

  inline WStringSeq(_CORBA_ULong _max)
    : _CORBA_Unbounded_Sequence_WString(_max) {}
  inline WStringSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::WChar** _val, _CORBA_Boolean _rel=0)
    : _CORBA_Unbounded_Sequence_WString(_max, _len, _val, _rel) {}



  inline WStringSeq& operator = (const WStringSeq& _s) {
    _CORBA_Unbounded_Sequence_WString::operator=(_s);
    return *this;
  }
};

class WStringSeq_out;

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



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

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

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



  WStringSeq*& _data;

private:
  WStringSeq_out();
  WStringSeq_out& operator=(const WStringSeq_var&);
};

#endif

