// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __SALOME__ModuleCatalog_hh__
#define __SALOME__ModuleCatalog_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_SALOME__ModuleCatalog
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__ModuleCatalog
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__ModuleCatalog
#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_MODULE SALOME_ModuleCatalog

_CORBA_MODULE_BEG

  enum ComponentType { GEOM, MESH, Med, SOLVER, DATA, VISU, SUPERV, OTHER /*, __max_ComponentType=0xffffffff */ };
  typedef ComponentType& ComponentType_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ComponentType;

  struct ServicesParameter {
    typedef _CORBA_ConstrType_Variable_Var<ServicesParameter> _var_type;

    
    ::CORBA::String_member Parametertype;

    ::CORBA::String_member Parametername;

  

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

  typedef ServicesParameter::_var_type ServicesParameter_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< ServicesParameter,ServicesParameter_var > ServicesParameter_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ServicesParameter;

  enum DataStreamDependency { DATASTREAM_UNDEFINED, DATASTREAM_TEMPORAL, DATASTREAM_ITERATIVE /*, __max_DataStreamDependency=0xffffffff */ };
  typedef DataStreamDependency& DataStreamDependency_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DataStreamDependency;

  struct ServicesDataStreamParameter {
    typedef _CORBA_ConstrType_Variable_Var<ServicesDataStreamParameter> _var_type;

    
    ::CORBA::String_member Parametertype;

    ::CORBA::String_member Parametername;

    DataStreamDependency Parameterdependency;

  

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

  typedef ServicesDataStreamParameter::_var_type ServicesDataStreamParameter_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< ServicesDataStreamParameter,ServicesDataStreamParameter_var > ServicesDataStreamParameter_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ServicesDataStreamParameter;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ListOfServicesParameter;

  class ListOfServicesParameter_var;

  class ListOfServicesParameter : public _CORBA_Unbounded_Sequence< ServicesParameter >  {
  public:
    typedef ListOfServicesParameter_var _var_type;
    inline ListOfServicesParameter() {}
    inline ListOfServicesParameter(const ListOfServicesParameter& _s)
      : _CORBA_Unbounded_Sequence< ServicesParameter > (_s) {}

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

  

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

  class ListOfServicesParameter_out;

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

  

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

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

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

  

    ListOfServicesParameter*& _data;

  private:
    ListOfServicesParameter_out();
    ListOfServicesParameter_out& operator=(const ListOfServicesParameter_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ListOfServicesDataStreamParameter;

  class ListOfServicesDataStreamParameter_var;

  class ListOfServicesDataStreamParameter : public _CORBA_Unbounded_Sequence< ServicesDataStreamParameter >  {
  public:
    typedef ListOfServicesDataStreamParameter_var _var_type;
    inline ListOfServicesDataStreamParameter() {}
    inline ListOfServicesDataStreamParameter(const ListOfServicesDataStreamParameter& _s)
      : _CORBA_Unbounded_Sequence< ServicesDataStreamParameter > (_s) {}

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

  

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

  class ListOfServicesDataStreamParameter_out;

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

  

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

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

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

  

    ListOfServicesDataStreamParameter*& _data;

  private:
    ListOfServicesDataStreamParameter_out();
    ListOfServicesDataStreamParameter_out& operator=(const ListOfServicesDataStreamParameter_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ListOfString;

  class ListOfString_var;

  class ListOfString : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef ListOfString_var _var_type;
    inline ListOfString() {}
    inline ListOfString(const ListOfString& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class ListOfString_out;

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

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

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

  

    ListOfString*& _data;

  private:
    ListOfString_out();
    ListOfString_out& operator=(const ListOfString_var&);
  };

  enum TypeKind { NONE, Dble, Int, Str, Bool, Objref, Seq, Array, Struc /*, __max_TypeKind=0xffffffff */ };
  typedef TypeKind& TypeKind_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_TypeKind;

  struct MemberDefinition {
    typedef _CORBA_ConstrType_Variable_Var<MemberDefinition> _var_type;

    
    ::CORBA::String_member name;

    ::CORBA::String_member type;

  

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

  typedef MemberDefinition::_var_type MemberDefinition_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< MemberDefinition,MemberDefinition_var > MemberDefinition_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_MemberDefinition;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ListOfMemberDefinition;

  class ListOfMemberDefinition_var;

  class ListOfMemberDefinition : public _CORBA_Unbounded_Sequence< MemberDefinition >  {
  public:
    typedef ListOfMemberDefinition_var _var_type;
    inline ListOfMemberDefinition() {}
    inline ListOfMemberDefinition(const ListOfMemberDefinition& _s)
      : _CORBA_Unbounded_Sequence< MemberDefinition > (_s) {}

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

  

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

  class ListOfMemberDefinition_out;

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

  

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

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

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

  

    ListOfMemberDefinition*& _data;

  private:
    ListOfMemberDefinition_out();
    ListOfMemberDefinition_out& operator=(const ListOfMemberDefinition_var&);
  };

  struct TypeDefinition {
    typedef _CORBA_ConstrType_Variable_Var<TypeDefinition> _var_type;

    
    ::CORBA::String_member name;

    TypeKind kind;

    ::CORBA::String_member id;

    ::CORBA::String_member content;

    ListOfString bases;

    ListOfMemberDefinition members;

  

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

  typedef TypeDefinition::_var_type TypeDefinition_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< TypeDefinition,TypeDefinition_var > TypeDefinition_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_TypeDefinition;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ListOfTypeDefinition;

  class ListOfTypeDefinition_var;

  class ListOfTypeDefinition : public _CORBA_Unbounded_Sequence< TypeDefinition >  {
  public:
    typedef ListOfTypeDefinition_var _var_type;
    inline ListOfTypeDefinition() {}
    inline ListOfTypeDefinition(const ListOfTypeDefinition& _s)
      : _CORBA_Unbounded_Sequence< TypeDefinition > (_s) {}

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

  

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

  class ListOfTypeDefinition_out;

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

  

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

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

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

  

    ListOfTypeDefinition*& _data;

  private:
    ListOfTypeDefinition_out();
    ListOfTypeDefinition_out& operator=(const ListOfTypeDefinition_var&);
  };

  struct Service {
    typedef _CORBA_ConstrType_Variable_Var<Service> _var_type;

    
    ::CORBA::String_member ServiceName;

    ListOfServicesParameter ServiceinParameter;

    ListOfServicesParameter ServiceoutParameter;

    ListOfServicesDataStreamParameter ServiceinDataStreamParameter;

    ListOfServicesDataStreamParameter ServiceoutDataStreamParameter;

    ::CORBA::Boolean Servicebydefault;

    ::CORBA::Boolean TypeOfNode;

  

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

  typedef Service::_var_type Service_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< Service,Service_var > Service_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Service;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ListOfInterfaceService;

  class ListOfInterfaceService_var;

  class ListOfInterfaceService : public _CORBA_Unbounded_Sequence< Service >  {
  public:
    typedef ListOfInterfaceService_var _var_type;
    inline ListOfInterfaceService() {}
    inline ListOfInterfaceService(const ListOfInterfaceService& _s)
      : _CORBA_Unbounded_Sequence< Service > (_s) {}

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

  

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

  class ListOfInterfaceService_out;

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

  

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

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

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

  

    ListOfInterfaceService*& _data;

  private:
    ListOfInterfaceService_out();
    ListOfInterfaceService_out& operator=(const ListOfInterfaceService_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ListOfServices;

  class ListOfServices_var;

  class ListOfServices : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef ListOfServices_var _var_type;
    inline ListOfServices() {}
    inline ListOfServices(const ListOfServices& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class ListOfServices_out;

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

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

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

  

    ListOfServices*& _data;

  private:
    ListOfServices_out();
    ListOfServices_out& operator=(const ListOfServices_var&);
  };

  struct DefinitionInterface {
    typedef _CORBA_ConstrType_Variable_Var<DefinitionInterface> _var_type;

    
    ::CORBA::String_member interfacename;

    ListOfInterfaceService interfaceservicelist;

  

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

  typedef DefinitionInterface::_var_type DefinitionInterface_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< DefinitionInterface,DefinitionInterface_var > DefinitionInterface_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DefinitionInterface;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ListOfDefInterface;

  class ListOfDefInterface_var;

  class ListOfDefInterface : public _CORBA_Unbounded_Sequence< DefinitionInterface >  {
  public:
    typedef ListOfDefInterface_var _var_type;
    inline ListOfDefInterface() {}
    inline ListOfDefInterface(const ListOfDefInterface& _s)
      : _CORBA_Unbounded_Sequence< DefinitionInterface > (_s) {}

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

  

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

  class ListOfDefInterface_out;

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

  

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

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

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

  

    ListOfDefInterface*& _data;

  private:
    ListOfDefInterface_out();
    ListOfDefInterface_out& operator=(const ListOfDefInterface_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ListOfInterfaces;

  class ListOfInterfaces_var;

  class ListOfInterfaces : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef ListOfInterfaces_var _var_type;
    inline ListOfInterfaces() {}
    inline ListOfInterfaces(const ListOfInterfaces& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class ListOfInterfaces_out;

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

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

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

  

    ListOfInterfaces*& _data;

  private:
    ListOfInterfaces_out();
    ListOfInterfaces_out& operator=(const ListOfInterfaces_var&);
  };

  struct PathPrefix {
    typedef _CORBA_ConstrType_Variable_Var<PathPrefix> _var_type;

    
    ::CORBA::String_member machine;

    ::CORBA::String_member path;

  

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

  typedef PathPrefix::_var_type PathPrefix_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< PathPrefix,PathPrefix_var > PathPrefix_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PathPrefix;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PathPrefixes;

  class PathPrefixes_var;

  class PathPrefixes : public _CORBA_Unbounded_Sequence< PathPrefix >  {
  public:
    typedef PathPrefixes_var _var_type;
    inline PathPrefixes() {}
    inline PathPrefixes(const PathPrefixes& _s)
      : _CORBA_Unbounded_Sequence< PathPrefix > (_s) {}

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

  

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

  class PathPrefixes_out;

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

  

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

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

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

  

    PathPrefixes*& _data;

  private:
    PathPrefixes_out();
    PathPrefixes_out& operator=(const PathPrefixes_var&);
  };

  enum ImplType { SO, PY, EXE, CEXE /*, __max_ImplType=0xffffffff */ };
  typedef ImplType& ImplType_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ImplType;

  struct ComponentDef {
    typedef _CORBA_ConstrType_Variable_Var<ComponentDef> _var_type;

    
    ComponentType type;

    ::CORBA::String_member name;

    ::CORBA::String_member username;

    ::CORBA::Boolean multistudy;

    ImplType implementationType;

    ::CORBA::String_member implname;

    ::CORBA::String_member icon;

    ::CORBA::String_member constraint;

    ListOfDefInterface interfaces;

    PathPrefixes paths;

  

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

  typedef ComponentDef::_var_type ComponentDef_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< ComponentDef,ComponentDef_var > ComponentDef_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ComponentDef;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ListOfComponents;

  class ListOfComponents_var;

  class ListOfComponents : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef ListOfComponents_var _var_type;
    inline ListOfComponents() {}
    inline ListOfComponents(const ListOfComponents& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class ListOfComponents_out;

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

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

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

  

    ListOfComponents*& _data;

  private:
    ListOfComponents_out();
    ListOfComponents_out& operator=(const ListOfComponents_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ListOfComputers;

  class ListOfComputers_var;

  class ListOfComputers : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef ListOfComputers_var _var_type;
    inline ListOfComputers() {}
    inline ListOfComputers(const ListOfComputers& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class ListOfComputers_out;

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

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

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

  

    ListOfComputers*& _data;

  private:
    ListOfComputers_out();
    ListOfComputers_out& operator=(const ListOfComputers_var&);
  };

  struct IAPP_Affich {
    typedef _CORBA_ConstrType_Variable_Var<IAPP_Affich> _var_type;

    
    ::CORBA::String_member modulename;

    ::CORBA::String_member moduleusername;

    ::CORBA::String_member moduleicone;

    ::CORBA::String_member moduleversion;

    ::CORBA::String_member modulecomment;

  

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

  typedef IAPP_Affich::_var_type IAPP_Affich_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< IAPP_Affich,IAPP_Affich_var > IAPP_Affich_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_IAPP_Affich;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ListOfIAPP_Affich;

  class ListOfIAPP_Affich_var;

  class ListOfIAPP_Affich : public _CORBA_Unbounded_Sequence< IAPP_Affich >  {
  public:
    typedef ListOfIAPP_Affich_var _var_type;
    inline ListOfIAPP_Affich() {}
    inline ListOfIAPP_Affich(const ListOfIAPP_Affich& _s)
      : _CORBA_Unbounded_Sequence< IAPP_Affich > (_s) {}

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

  

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

  class ListOfIAPP_Affich_out;

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

  

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

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

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

  

    ListOfIAPP_Affich*& _data;

  private:
    ListOfIAPP_Affich_out();
    ListOfIAPP_Affich_out& operator=(const ListOfIAPP_Affich_var&);
  };

  class NotFound : public ::CORBA::UserException {
  public:
    
    ::CORBA::String_member what;

  

    inline NotFound() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    NotFound(const NotFound&);
    NotFound(const char* i_what);
    NotFound& operator=(const NotFound&);
    virtual ~NotFound();
    virtual void _raise() const;
    static NotFound* _downcast(::CORBA::Exception*);
    static const NotFound* _downcast(const ::CORBA::Exception*);
    static inline NotFound* _narrow(::CORBA::Exception* _e) {
      return _downcast(_e);
    }
    
    void operator>>=(cdrStream&) const ;
    void operator<<=(cdrStream&) ;

    static _core_attr insertExceptionToAny    insertToAnyFn;
    static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

    virtual ::CORBA::Exception* _NP_duplicate() const;

    static _core_attr const char* _PD_repoId;
    static _core_attr const char* _PD_typeId;

  private:
    virtual const char* _NP_typeId() const;
    virtual const char* _NP_repoId(int*) const;
    virtual void _NP_marshal(cdrStream&) const;
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_NotFound;

#ifndef __SALOME__ModuleCatalog_mAcomponent__
#define __SALOME__ModuleCatalog_mAcomponent__

  class Acomponent;
  class _objref_Acomponent;
  class _impl_Acomponent;
  
  typedef _objref_Acomponent* Acomponent_ptr;
  typedef Acomponent_ptr AcomponentRef;

  class Acomponent_Helper {
  public:
    typedef Acomponent_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_Acomponent, Acomponent_Helper> Acomponent_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Acomponent,Acomponent_Helper > Acomponent_out;

#endif

  // interface Acomponent
  class Acomponent {
  public:
    // Declarations for this interface type.
    typedef Acomponent_ptr _ptr_type;
    typedef Acomponent_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
    
    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.
    
  };

  class _objref_Acomponent :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ListOfInterfaces* GetInterfaceList();
    DefinitionInterface* GetInterface(const char* interfacename);
    ListOfServices* GetServiceList(const char* interfacename);
    Service* GetService(const char* interfacename, const char* servicename);
    Service* GetDefaultService(const char* interfacename);
    char* GetPathPrefix(const char* machinename);
    char* constraint();
    char* componentname();
    char* componentusername();
    ::CORBA::Boolean multistudy();
    ComponentType component_type();
    char* component_icone();
    ImplType implementation_type();
    char* implementation_name();

    inline _objref_Acomponent()  { _PR_setobj(0); }  // nil
    _objref_Acomponent(omniIOR*, omniIdentity*);

  protected:
    virtual ~_objref_Acomponent();

    
  private:
    virtual void* _ptrToObjRef(const char*);

    _objref_Acomponent(const _objref_Acomponent&);
    _objref_Acomponent& operator = (const _objref_Acomponent&);
    // not implemented

    friend class Acomponent;
  };

  class _pof_Acomponent : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Acomponent() : _OMNI_NS(proxyObjectFactory)(Acomponent::_PD_repoId) {}
    virtual ~_pof_Acomponent();

    virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
    virtual _CORBA_Boolean is_a(const char*) const;
  };

  class _impl_Acomponent :
    public virtual omniServant
  {
  public:
    virtual ~_impl_Acomponent();

    virtual ListOfInterfaces* GetInterfaceList() = 0;
    virtual DefinitionInterface* GetInterface(const char* interfacename) = 0;
    virtual ListOfServices* GetServiceList(const char* interfacename) = 0;
    virtual Service* GetService(const char* interfacename, const char* servicename) = 0;
    virtual Service* GetDefaultService(const char* interfacename) = 0;
    virtual char* GetPathPrefix(const char* machinename) = 0;
    virtual char* constraint() = 0;
    virtual char* componentname() = 0;
    virtual char* componentusername() = 0;
    virtual ::CORBA::Boolean multistudy() = 0;
    virtual ComponentType component_type() = 0;
    virtual char* component_icone() = 0;
    virtual ImplType implementation_type() = 0;
    virtual char* implementation_name() = 0;
    
  public:  // Really protected, workaround for xlC
    virtual _CORBA_Boolean _dispatch(omniCallHandle&);

  private:
    virtual void* _ptrToInterface(const char*);
    virtual const char* _mostDerivedRepoId();
    
  };


  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Acomponent;

#ifndef __SALOME__ModuleCatalog_mModuleCatalog__
#define __SALOME__ModuleCatalog_mModuleCatalog__

  class ModuleCatalog;
  class _objref_ModuleCatalog;
  class _impl_ModuleCatalog;
  
  typedef _objref_ModuleCatalog* ModuleCatalog_ptr;
  typedef ModuleCatalog_ptr ModuleCatalogRef;

  class ModuleCatalog_Helper {
  public:
    typedef ModuleCatalog_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_ModuleCatalog, ModuleCatalog_Helper> ModuleCatalog_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_ModuleCatalog,ModuleCatalog_Helper > ModuleCatalog_out;

#endif

  // interface ModuleCatalog
  class ModuleCatalog {
  public:
    // Declarations for this interface type.
    typedef ModuleCatalog_ptr _ptr_type;
    typedef ModuleCatalog_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
    
    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.
    
  };

  class _objref_ModuleCatalog :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    void ping();
    ::CORBA::Long getPID();
    void ShutdownWithExit();
    ListOfTypeDefinition* GetTypes();
    ListOfComputers* GetComputerList();
    char* GetPathPrefix(const char* machinename);
    ListOfComponents* GetComponentList();
    ListOfIAPP_Affich* GetComponentIconeList();
    ListOfComponents* GetTypedComponentList(::SALOME_ModuleCatalog::ComponentType component_type);
    Acomponent_ptr GetComponent(const char* componentname);
    ComponentDef* GetComponentInfo(const char* componentName);
    void ImportXmlCatalogFile(const char* filename);
    void shutdown();

    inline _objref_ModuleCatalog()  { _PR_setobj(0); }  // nil
    _objref_ModuleCatalog(omniIOR*, omniIdentity*);

  protected:
    virtual ~_objref_ModuleCatalog();

    
  private:
    virtual void* _ptrToObjRef(const char*);

    _objref_ModuleCatalog(const _objref_ModuleCatalog&);
    _objref_ModuleCatalog& operator = (const _objref_ModuleCatalog&);
    // not implemented

    friend class ModuleCatalog;
  };

  class _pof_ModuleCatalog : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_ModuleCatalog() : _OMNI_NS(proxyObjectFactory)(ModuleCatalog::_PD_repoId) {}
    virtual ~_pof_ModuleCatalog();

    virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
    virtual _CORBA_Boolean is_a(const char*) const;
  };

  class _impl_ModuleCatalog :
    public virtual omniServant
  {
  public:
    virtual ~_impl_ModuleCatalog();

    virtual void ping() = 0;
    virtual ::CORBA::Long getPID() = 0;
    virtual void ShutdownWithExit() = 0;
    virtual ListOfTypeDefinition* GetTypes() = 0;
    virtual ListOfComputers* GetComputerList() = 0;
    virtual char* GetPathPrefix(const char* machinename) = 0;
    virtual ListOfComponents* GetComponentList() = 0;
    virtual ListOfIAPP_Affich* GetComponentIconeList() = 0;
    virtual ListOfComponents* GetTypedComponentList(::SALOME_ModuleCatalog::ComponentType component_type) = 0;
    virtual Acomponent_ptr GetComponent(const char* componentname) = 0;
    virtual ComponentDef* GetComponentInfo(const char* componentName) = 0;
    virtual void ImportXmlCatalogFile(const char* filename) = 0;
    virtual void shutdown() = 0;
    
  public:  // Really protected, workaround for xlC
    virtual _CORBA_Boolean _dispatch(omniCallHandle&);

  private:
    virtual void* _ptrToInterface(const char*);
    virtual const char* _mostDerivedRepoId();
    
  };


  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ModuleCatalog;

_CORBA_MODULE_END



_CORBA_MODULE POA_SALOME_ModuleCatalog
_CORBA_MODULE_BEG

  class Acomponent :
    public virtual SALOME_ModuleCatalog::_impl_Acomponent,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~Acomponent();

    inline ::SALOME_ModuleCatalog::Acomponent_ptr _this() {
      return (::SALOME_ModuleCatalog::Acomponent_ptr) _do_this(::SALOME_ModuleCatalog::Acomponent::_PD_repoId);
    }
  };

  class ModuleCatalog :
    public virtual SALOME_ModuleCatalog::_impl_ModuleCatalog,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~ModuleCatalog();

    inline ::SALOME_ModuleCatalog::ModuleCatalog_ptr _this() {
      return (::SALOME_ModuleCatalog::ModuleCatalog_ptr) _do_this(::SALOME_ModuleCatalog::ModuleCatalog::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_SALOME_ModuleCatalog
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

inline void operator >>=(SALOME_ModuleCatalog::ComponentType _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (SALOME_ModuleCatalog::ComponentType& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= SALOME_ModuleCatalog::OTHER) {
    _e = (SALOME_ModuleCatalog::ComponentType) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, SALOME_ModuleCatalog::ComponentType _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, SALOME_ModuleCatalog::ComponentType& _s);

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

inline void operator >>=(SALOME_ModuleCatalog::DataStreamDependency _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (SALOME_ModuleCatalog::DataStreamDependency& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= SALOME_ModuleCatalog::DATASTREAM_ITERATIVE) {
    _e = (SALOME_ModuleCatalog::DataStreamDependency) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, SALOME_ModuleCatalog::DataStreamDependency _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, SALOME_ModuleCatalog::DataStreamDependency& _s);

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

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

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

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

inline void operator >>=(SALOME_ModuleCatalog::TypeKind _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (SALOME_ModuleCatalog::TypeKind& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= SALOME_ModuleCatalog::Struc) {
    _e = (SALOME_ModuleCatalog::TypeKind) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, SALOME_ModuleCatalog::TypeKind _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, SALOME_ModuleCatalog::TypeKind& _s);

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

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

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

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

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

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

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

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

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

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

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

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

inline void operator >>=(SALOME_ModuleCatalog::ImplType _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (SALOME_ModuleCatalog::ImplType& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= SALOME_ModuleCatalog::CEXE) {
    _e = (SALOME_ModuleCatalog::ImplType) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, SALOME_ModuleCatalog::ImplType _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, SALOME_ModuleCatalog::ImplType& _s);

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

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

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

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

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

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

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

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



inline void
SALOME_ModuleCatalog::Acomponent::_marshalObjRef(::SALOME_ModuleCatalog::Acomponent_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME_ModuleCatalog::ModuleCatalog::_marshalObjRef(::SALOME_ModuleCatalog::ModuleCatalog_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_SALOME__ModuleCatalog
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_SALOME__ModuleCatalog
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__ModuleCatalog
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__ModuleCatalog
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__ModuleCatalog
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__ModuleCatalog
#endif

#endif  // __SALOME__ModuleCatalog_hh__

