// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __SALOME__ContainerManager_hh__
#define __SALOME__ContainerManager_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__ContainerManager
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__ContainerManager
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__ContainerManager
#endif



#ifndef __SALOME__Exception_hh_EXTERNAL_GUARD__
#define __SALOME__Exception_hh_EXTERNAL_GUARD__
#include <SALOME_Exception.hh>
#endif
#ifndef __SALOME__GenericObj_hh_EXTERNAL_GUARD__
#define __SALOME__GenericObj_hh_EXTERNAL_GUARD__
#include <SALOME_GenericObj.hh>
#endif
#ifndef __SALOMEDS_hh_EXTERNAL_GUARD__
#define __SALOMEDS_hh_EXTERNAL_GUARD__
#include <SALOMEDS.hh>
#endif
#ifndef __SALOME__PyNode_hh_EXTERNAL_GUARD__
#define __SALOME__PyNode_hh_EXTERNAL_GUARD__
#include <SALOME_PyNode.hh>
#endif
#ifndef __SALOME__Component_hh_EXTERNAL_GUARD__
#define __SALOME__Component_hh_EXTERNAL_GUARD__
#include <SALOME_Component.hh>
#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 Engines

_CORBA_MODULE_BEG

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ResourceList;

  class ResourceList_var;

  class ResourceList : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef ResourceList_var _var_type;
    inline ResourceList() {}
    inline ResourceList(const ResourceList& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class ResourceList_out;

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

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

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

  

    ResourceList*& _data;

  private:
    ResourceList_out();
    ResourceList_out& operator=(const ResourceList_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CompoList;

  class CompoList_var;

  class CompoList : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef CompoList_var _var_type;
    inline CompoList() {}
    inline CompoList(const CompoList& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class CompoList_out;

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

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

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

  

    CompoList*& _data;

  private:
    CompoList_out();
    CompoList_out& operator=(const CompoList_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_FilesList;

  class FilesList_var;

  class FilesList : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef FilesList_var _var_type;
    inline FilesList() {}
    inline FilesList(const FilesList& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class FilesList_out;

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

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

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

  

    FilesList*& _data;

  private:
    FilesList_out();
    FilesList_out& operator=(const FilesList_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ModulesList;

  class ModulesList_var;

  class ModulesList : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef ModulesList_var _var_type;
    inline ModulesList() {}
    inline ModulesList(const ModulesList& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class ModulesList_out;

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

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

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

  

    ModulesList*& _data;

  private:
    ModulesList_out();
    ModulesList_out& operator=(const ModulesList_var&);
  };

  struct Parameter {
    typedef _CORBA_ConstrType_Variable_Var<Parameter> _var_type;

    
    ::CORBA::String_member name;

    ::CORBA::String_member value;

  

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

  typedef Parameter::_var_type Parameter_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< Parameter,Parameter_var > Parameter_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Parameter;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ParameterList;

  class ParameterList_var;

  class ParameterList : public _CORBA_Unbounded_Sequence< Parameter >  {
  public:
    typedef ParameterList_var _var_type;
    inline ParameterList() {}
    inline ParameterList(const ParameterList& _s)
      : _CORBA_Unbounded_Sequence< Parameter > (_s) {}

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

  

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

  class ParameterList_out;

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

  

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

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

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

  

    ParameterList*& _data;

  private:
    ParameterList_out();
    ParameterList_out& operator=(const ParameterList_var&);
  };

  struct ResourceParameters {
    typedef _CORBA_ConstrType_Variable_Var<ResourceParameters> _var_type;

    
    ::CORBA::String_member name;

    ::CORBA::String_member hostname;

    ::CORBA::String_member OS;

    CompoList componentList;

    ::CORBA::Long nb_proc;

    ::CORBA::Long mem_mb;

    ::CORBA::Long cpu_clock;

    ::CORBA::Long nb_node;

    ::CORBA::Long nb_proc_per_node;

    ::CORBA::String_member policy;

    ResourceList resList;

  

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

  typedef ResourceParameters::_var_type ResourceParameters_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< ResourceParameters,ResourceParameters_var > ResourceParameters_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ResourceParameters;

  struct ContainerParameters {
    typedef _CORBA_ConstrType_Variable_Var<ContainerParameters> _var_type;

    
    ::CORBA::String_member container_name;

    ::CORBA::String_member mode;

    ::CORBA::String_member workingdir;

    ::CORBA::Long nb_proc;

    ::CORBA::Boolean isMPI;

    ::CORBA::String_member parallelLib;

    ResourceParameters resource_params;

  

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

  typedef ContainerParameters::_var_type ContainerParameters_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< ContainerParameters,ContainerParameters_var > ContainerParameters_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ContainerParameters;

  struct ResourceDefinition {
    typedef _CORBA_ConstrType_Variable_Var<ResourceDefinition> _var_type;

    
    ::CORBA::String_member name;

    ::CORBA::String_member hostname;

    ::CORBA::String_member protocol;

    ::CORBA::String_member username;

    ::CORBA::String_member applipath;

    CompoList componentList;

    ::CORBA::String_member mode;

    ::CORBA::String_member OS;

    ::CORBA::Long mem_mb;

    ::CORBA::Long cpu_clock;

    ::CORBA::Long nb_node;

    ::CORBA::Long nb_proc_per_node;

    ::CORBA::String_member batch;

    ::CORBA::String_member mpiImpl;

    ::CORBA::String_member iprotocol;

  

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

  typedef ResourceDefinition::_var_type ResourceDefinition_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< ResourceDefinition,ResourceDefinition_var > ResourceDefinition_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ResourceDefinition;

  class NotFound : public ::CORBA::UserException {
  public:
    
    

    inline NotFound() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    NotFound(const NotFound&);
    
    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);
    }
    
    inline void operator>>=(cdrStream&) const { }
    inline 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;

  struct JobParameters {
    typedef _CORBA_ConstrType_Variable_Var<JobParameters> _var_type;

    
    ::CORBA::String_member job_type;

    ::CORBA::String_member job_file;

    ::CORBA::String_member env_file;

    FilesList in_files;

    FilesList out_files;

    ::CORBA::String_member work_directory;

    ::CORBA::String_member local_directory;

    ::CORBA::String_member result_directory;

    ::CORBA::String_member maximum_duration;

    ResourceParameters resource_required;

    ::CORBA::String_member queue;

    ParameterList specific_parameters;

  

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

  typedef JobParameters::_var_type JobParameters_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< JobParameters,JobParameters_var > JobParameters_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_JobParameters;

#ifndef __Engines_mSalomeLauncher__
#define __Engines_mSalomeLauncher__

  class SalomeLauncher;
  class _objref_SalomeLauncher;
  class _impl_SalomeLauncher;
  
  typedef _objref_SalomeLauncher* SalomeLauncher_ptr;
  typedef SalomeLauncher_ptr SalomeLauncherRef;

  class SalomeLauncher_Helper {
  public:
    typedef SalomeLauncher_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_SalomeLauncher, SalomeLauncher_Helper> SalomeLauncher_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SalomeLauncher,SalomeLauncher_Helper > SalomeLauncher_out;

#endif

  // interface SalomeLauncher
  class SalomeLauncher {
  public:
    // Declarations for this interface type.
    typedef SalomeLauncher_ptr _ptr_type;
    typedef SalomeLauncher_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_SalomeLauncher :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::Long createJob(const ::Engines::JobParameters& job_parameters);
    void launchJob(::CORBA::Long job_id);
    char* getJobState(::CORBA::Long job_id);
    void getJobResults(::CORBA::Long job_id, const char* directory);
    void removeJob(::CORBA::Long job_id);
    ::CORBA::Long createJobWithFile(const char* xmlJobFile, const char* clusterName);
    ::CORBA::Boolean testBatch(const ::Engines::ResourceParameters& params);
    void Shutdown();
    ::CORBA::Long getPID();

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

  protected:
    virtual ~_objref_SalomeLauncher();

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

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

    friend class SalomeLauncher;
  };

  class _pof_SalomeLauncher : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SalomeLauncher() : _OMNI_NS(proxyObjectFactory)(SalomeLauncher::_PD_repoId) {}
    virtual ~_pof_SalomeLauncher();

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

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

    virtual ::CORBA::Long createJob(const ::Engines::JobParameters& job_parameters) = 0;
    virtual void launchJob(::CORBA::Long job_id) = 0;
    virtual char* getJobState(::CORBA::Long job_id) = 0;
    virtual void getJobResults(::CORBA::Long job_id, const char* directory) = 0;
    virtual void removeJob(::CORBA::Long job_id) = 0;
    virtual ::CORBA::Long createJobWithFile(const char* xmlJobFile, const char* clusterName) = 0;
    virtual ::CORBA::Boolean testBatch(const ::Engines::ResourceParameters& params) = 0;
    virtual void Shutdown() = 0;
    virtual ::CORBA::Long getPID() = 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_SalomeLauncher;

#ifndef __Engines_mContainerManager__
#define __Engines_mContainerManager__

  class ContainerManager;
  class _objref_ContainerManager;
  class _impl_ContainerManager;
  
  typedef _objref_ContainerManager* ContainerManager_ptr;
  typedef ContainerManager_ptr ContainerManagerRef;

  class ContainerManager_Helper {
  public:
    typedef ContainerManager_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_ContainerManager, ContainerManager_Helper> ContainerManager_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_ContainerManager,ContainerManager_Helper > ContainerManager_out;

#endif

  // interface ContainerManager
  class ContainerManager {
  public:
    // Declarations for this interface type.
    typedef ContainerManager_ptr _ptr_type;
    typedef ContainerManager_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_ContainerManager :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    Container_ptr GiveContainer(const ::Engines::ContainerParameters& params);
    void ShutdownContainers();

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

  protected:
    virtual ~_objref_ContainerManager();

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

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

    friend class ContainerManager;
  };

  class _pof_ContainerManager : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_ContainerManager() : _OMNI_NS(proxyObjectFactory)(ContainerManager::_PD_repoId) {}
    virtual ~_pof_ContainerManager();

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

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

    virtual Container_ptr GiveContainer(const ::Engines::ContainerParameters& params) = 0;
    virtual void ShutdownContainers() = 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_ContainerManager;

#ifndef __Engines_mResourcesManager__
#define __Engines_mResourcesManager__

  class ResourcesManager;
  class _objref_ResourcesManager;
  class _impl_ResourcesManager;
  
  typedef _objref_ResourcesManager* ResourcesManager_ptr;
  typedef ResourcesManager_ptr ResourcesManagerRef;

  class ResourcesManager_Helper {
  public:
    typedef ResourcesManager_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_ResourcesManager, ResourcesManager_Helper> ResourcesManager_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_ResourcesManager,ResourcesManager_Helper > ResourcesManager_out;

#endif

  // interface ResourcesManager
  class ResourcesManager {
  public:
    // Declarations for this interface type.
    typedef ResourcesManager_ptr _ptr_type;
    typedef ResourcesManager_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_ResourcesManager :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    char* FindFirst(const ::Engines::ResourceList& possibleResources);
    char* Find(const char* policy, const ::Engines::ResourceList& possibleResources);
    ResourceList* GetFittingResources(const ::Engines::ResourceParameters& params);
    ResourceDefinition* GetResourceDefinition(const char* name);
    void AddResource(const ::Engines::ResourceDefinition& new_resource, ::CORBA::Boolean write, const char* xml_file);
    void RemoveResource(const char* resource_name, ::CORBA::Boolean write, const char* xml_file);

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

  protected:
    virtual ~_objref_ResourcesManager();

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

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

    friend class ResourcesManager;
  };

  class _pof_ResourcesManager : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_ResourcesManager() : _OMNI_NS(proxyObjectFactory)(ResourcesManager::_PD_repoId) {}
    virtual ~_pof_ResourcesManager();

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

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

    virtual char* FindFirst(const ::Engines::ResourceList& possibleResources) = 0;
    virtual char* Find(const char* policy, const ::Engines::ResourceList& possibleResources) = 0;
    virtual ResourceList* GetFittingResources(const ::Engines::ResourceParameters& params) = 0;
    virtual ResourceDefinition* GetResourceDefinition(const char* name) = 0;
    virtual void AddResource(const ::Engines::ResourceDefinition& new_resource, ::CORBA::Boolean write, const char* xml_file) = 0;
    virtual void RemoveResource(const char* resource_name, ::CORBA::Boolean write, const char* xml_file) = 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_ResourcesManager;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_MachineList;

  class MachineList_var;

  class MachineList : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef MachineList_var _var_type;
    inline MachineList() {}
    inline MachineList(const MachineList& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class MachineList_out;

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

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

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

  

    MachineList*& _data;

  private:
    MachineList_out();
    MachineList_out& operator=(const MachineList_var&);
  };

  struct MachineParameters {
    typedef _CORBA_ConstrType_Variable_Var<MachineParameters> _var_type;

    
    ::CORBA::String_member container_name;

    ::CORBA::String_member hostname;

    CompoList componentList;

    MachineList computerList;

    ::CORBA::String_member OS;

    ::CORBA::Long mem_mb;

    ::CORBA::Long cpu_clock;

    ::CORBA::Long nb_proc_per_node;

    ::CORBA::Long nb_node;

    ::CORBA::Boolean isMPI;

    ::CORBA::String_member workingdir;

    ::CORBA::String_member mode;

    ::CORBA::String_member policy;

    ::CORBA::String_member parallelLib;

    ::CORBA::Long nb_component_nodes;

  

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

  typedef MachineParameters::_var_type MachineParameters_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< MachineParameters,MachineParameters_var > MachineParameters_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_MachineParameters;

_CORBA_MODULE_END



_CORBA_MODULE POA_Engines
_CORBA_MODULE_BEG

  class SalomeLauncher :
    public virtual Engines::_impl_SalomeLauncher,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~SalomeLauncher();

    inline ::Engines::SalomeLauncher_ptr _this() {
      return (::Engines::SalomeLauncher_ptr) _do_this(::Engines::SalomeLauncher::_PD_repoId);
    }
  };

  class ContainerManager :
    public virtual Engines::_impl_ContainerManager,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~ContainerManager();

    inline ::Engines::ContainerManager_ptr _this() {
      return (::Engines::ContainerManager_ptr) _do_this(::Engines::ContainerManager::_PD_repoId);
    }
  };

  class ResourcesManager :
    public virtual Engines::_impl_ResourcesManager,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~ResourcesManager();

    inline ::Engines::ResourcesManager_ptr _this() {
      return (::Engines::ResourcesManager_ptr) _do_this(::Engines::ResourcesManager::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_Engines
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



inline void
Engines::SalomeLauncher::_marshalObjRef(::Engines::SalomeLauncher_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Engines::ContainerManager::_marshalObjRef(::Engines::ContainerManager_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Engines::ResourcesManager::_marshalObjRef(::Engines::ResourcesManager_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_SALOME__ContainerManager
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_SALOME__ContainerManager
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__ContainerManager
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__ContainerManager
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__ContainerManager
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__ContainerManager
#endif

#endif  // __SALOME__ContainerManager_hh__

