/usr/include/salome/SALOME

// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __SALOME__Component_hh__
#define __SALOME__Component_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__Component
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__Component
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__Component
#endif



#ifndef __SALOME__GenericObj_hh_EXTERNAL_GUARD__
#define __SALOME__GenericObj_hh_EXTERNAL_GUARD__
#include <SALOME_GenericObj.hh>
#endif
#ifndef __SALOME__Exception_hh_EXTERNAL_GUARD__
#define __SALOME__Exception_hh_EXTERNAL_GUARD__
#include <SALOME_Exception.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



#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_TMPFile;

  class TMPFile_var;

  class TMPFile : public _CORBA_Unbounded_Sequence_Octet {
  public:
    typedef TMPFile_var _var_type;
    inline TMPFile() {}
    inline TMPFile(const TMPFile& _s)
      : _CORBA_Unbounded_Sequence_Octet(_s) {}

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

  

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

  class TMPFile_out;

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

  

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

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

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

  

    TMPFile*& _data;

  private:
    TMPFile_out();
    TMPFile_out& operator=(const TMPFile_var&);
  };

  struct KeyValuePair {
    typedef _CORBA_ConstrType_Variable_Var<KeyValuePair> _var_type;

    
    ::CORBA::String_member key;

    ::CORBA::Any value;

  

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

  typedef KeyValuePair::_var_type KeyValuePair_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< KeyValuePair,KeyValuePair_var > KeyValuePair_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_KeyValuePair;

  struct dataref {
    typedef _CORBA_ConstrType_Variable_Var<dataref> _var_type;

    
    ::CORBA::String_member ref;

  

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

  typedef dataref::_var_type dataref_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< dataref,dataref_var > dataref_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_dataref;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_FieldsDict;

  class FieldsDict_var;

  class FieldsDict : public _CORBA_Unbounded_Sequence< KeyValuePair >  {
  public:
    typedef FieldsDict_var _var_type;
    inline FieldsDict() {}
    inline FieldsDict(const FieldsDict& _s)
      : _CORBA_Unbounded_Sequence< KeyValuePair > (_s) {}

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

  

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

  class FieldsDict_out;

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

  

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

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

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

  

    FieldsDict*& _data;

  private:
    FieldsDict_out();
    FieldsDict_out& operator=(const FieldsDict_var&);
  };

#ifndef __Engines_mEngineComponent__
#define __Engines_mEngineComponent__

  class EngineComponent;
  class _objref_EngineComponent;
  class _impl_EngineComponent;
  
  typedef _objref_EngineComponent* EngineComponent_ptr;
  typedef EngineComponent_ptr EngineComponentRef;

  class EngineComponent_Helper {
  public:
    typedef EngineComponent_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_EngineComponent, EngineComponent_Helper> EngineComponent_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EngineComponent,EngineComponent_Helper > EngineComponent_out;

#endif

#ifndef __Engines_mfileRef__
#define __Engines_mfileRef__

  class fileRef;
  class _objref_fileRef;
  class _impl_fileRef;
  
  typedef _objref_fileRef* fileRef_ptr;
  typedef fileRef_ptr fileRefRef;

  class fileRef_Helper {
  public:
    typedef fileRef_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_fileRef, fileRef_Helper> fileRef_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_fileRef,fileRef_Helper > fileRef_out;

#endif

#ifndef __Engines_mfileTransfer__
#define __Engines_mfileTransfer__

  class fileTransfer;
  class _objref_fileTransfer;
  class _impl_fileTransfer;
  
  typedef _objref_fileTransfer* fileTransfer_ptr;
  typedef fileTransfer_ptr fileTransferRef;

  class fileTransfer_Helper {
  public:
    typedef fileTransfer_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_fileTransfer, fileTransfer_Helper> fileTransfer_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_fileTransfer,fileTransfer_Helper > fileTransfer_out;

#endif

#ifndef __Engines_mSalome__file__
#define __Engines_mSalome__file__

  class Salome_file;
  class _objref_Salome_file;
  class _impl_Salome_file;
  
  typedef _objref_Salome_file* Salome_file_ptr;
  typedef Salome_file_ptr Salome_fileRef;

  class Salome_file_Helper {
  public:
    typedef Salome_file_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_Salome_file, Salome_file_Helper> Salome_file_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Salome_file,Salome_file_Helper > Salome_file_out;

#endif

#ifndef __Engines_mContainer__
#define __Engines_mContainer__

  class Container;
  class _objref_Container;
  class _impl_Container;
  
  typedef _objref_Container* Container_ptr;
  typedef Container_ptr ContainerRef;

  class Container_Helper {
  public:
    typedef Container_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_Container, Container_Helper> Container_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Container,Container_Helper > Container_out;

#endif

  // interface Container
  class Container {
  public:
    // Declarations for this interface type.
    typedef Container_ptr _ptr_type;
    typedef Container_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_Container :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::Boolean load_component_Library(const char* componentName, ::CORBA::String_out reason);
    EngineComponent_ptr create_component_instance(const char* componentName, ::CORBA::Long studyId);
    EngineComponent_ptr create_component_instance_env(const char* componentName, ::CORBA::Long studyId, const ::Engines::FieldsDict& env, ::CORBA::String_out reason);
    EngineComponent_ptr find_component_instance(const char* registeredName, ::CORBA::Long studyId);
    EngineComponent_ptr load_impl(const char* nameToRegister, const char* componentName);
    void remove_impl(::Engines::EngineComponent_ptr component_i);
    void finalize_removal();
    void ping();
    void Shutdown();
    char* getHostName();
    ::CORBA::Long getPID();
    ::CORBA::Boolean Kill_impl();
    fileRef_ptr createFileRef(const char* origFileName);
    Salome_file_ptr createSalome_file(const char* origFileName);
    fileTransfer_ptr getFileTransfer();
    void copyFile(::Engines::Container_ptr contai, const char* remoteFile, const char* localFile);
    PyNode_ptr createPyNode(const char* nodeName, const char* code);
    PyScriptNode_ptr createPyScriptNode(const char* nodeName, const char* code);
    char* name();
    char* workingdir();
    char* logfilename();
    void logfilename(const char* _v);

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

  protected:
    virtual ~_objref_Container();

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

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

    friend class Container;
  };

  class _pof_Container : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Container() : _OMNI_NS(proxyObjectFactory)(Container::_PD_repoId) {}
    virtual ~_pof_Container();

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

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

    virtual ::CORBA::Boolean load_component_Library(const char* componentName, ::CORBA::String_out reason) = 0;
    virtual EngineComponent_ptr create_component_instance(const char* componentName, ::CORBA::Long studyId) = 0;
    virtual EngineComponent_ptr create_component_instance_env(const char* componentName, ::CORBA::Long studyId, const ::Engines::FieldsDict& env, ::CORBA::String_out reason) = 0;
    virtual EngineComponent_ptr find_component_instance(const char* registeredName, ::CORBA::Long studyId) = 0;
    virtual EngineComponent_ptr load_impl(const char* nameToRegister, const char* componentName) = 0;
    virtual void remove_impl(::Engines::EngineComponent_ptr component_i) = 0;
    virtual void finalize_removal() = 0;
    virtual void ping() = 0;
    virtual void Shutdown() = 0;
    virtual char* getHostName() = 0;
    virtual ::CORBA::Long getPID() = 0;
    virtual ::CORBA::Boolean Kill_impl() = 0;
    virtual fileRef_ptr createFileRef(const char* origFileName) = 0;
    virtual Salome_file_ptr createSalome_file(const char* origFileName) = 0;
    virtual fileTransfer_ptr getFileTransfer() = 0;
    virtual void copyFile(::Engines::Container_ptr contai, const char* remoteFile, const char* localFile) = 0;
    virtual PyNode_ptr createPyNode(const char* nodeName, const char* code) = 0;
    virtual PyScriptNode_ptr createPyScriptNode(const char* nodeName, const char* code) = 0;
    virtual char* name() = 0;
    virtual char* workingdir() = 0;
    virtual char* logfilename() = 0;
    virtual void logfilename(const char* _v) = 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_Container;

#ifndef __Engines_mEngineComponent__
#define __Engines_mEngineComponent__

  class EngineComponent;
  class _objref_EngineComponent;
  class _impl_EngineComponent;
  
  typedef _objref_EngineComponent* EngineComponent_ptr;
  typedef EngineComponent_ptr EngineComponentRef;

  class EngineComponent_Helper {
  public:
    typedef EngineComponent_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_EngineComponent, EngineComponent_Helper> EngineComponent_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EngineComponent,EngineComponent_Helper > EngineComponent_out;

#endif

  // interface EngineComponent
  class EngineComponent {
  public:
    // Declarations for this interface type.
    typedef EngineComponent_ptr _ptr_type;
    typedef EngineComponent_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_EngineComponent :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    void ping();
    ::CORBA::Long getStudyId();
    void destroy();
    Container_ptr GetContainerRef();
    void setProperties(const ::Engines::FieldsDict& dico);
    FieldsDict* getProperties();
    void SetOption(const char* optionName, const char* value);
    char* GetOption(const char* optionName);
    void Names(const char* aGraphName, const char* aNodeName);
    ::CORBA::Boolean Kill_impl();
    ::CORBA::Boolean Stop_impl();
    ::CORBA::Boolean Suspend_impl();
    ::CORBA::Boolean Resume_impl();
    ::CORBA::Long CpuUsed_impl();
    TMPFile* DumpPython(::CORBA::Object_ptr theStudy, ::CORBA::Boolean isPublished, ::CORBA::Boolean isMultiFile, ::CORBA::Boolean& isValidScript);
    Salome_file_ptr getInputFileToService(const char* service_name, const char* Salome_file_name);
    void checkInputFilesToService(const char* service_name);
    Salome_file_ptr setInputFileToService(const char* service_name, const char* Salome_file_name);
    Salome_file_ptr getOutputFileToService(const char* service_name, const char* Salome_file_name);
    void checkOutputFilesToService(const char* service_name);
    Salome_file_ptr setOutputFileToService(const char* service_name, const char* Salome_file_name);
    ::CORBA::Boolean hasObjectInfo();
    char* getObjectInfo(::CORBA::Long studyId, const char* entry);
    char* instanceName();
    char* interfaceName();

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

  protected:
    virtual ~_objref_EngineComponent();

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

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

    friend class EngineComponent;
  };

  class _pof_EngineComponent : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_EngineComponent() : _OMNI_NS(proxyObjectFactory)(EngineComponent::_PD_repoId) {}
    virtual ~_pof_EngineComponent();

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

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

    virtual void ping() = 0;
    virtual ::CORBA::Long getStudyId() = 0;
    virtual void destroy() = 0;
    virtual Container_ptr GetContainerRef() = 0;
    virtual void setProperties(const ::Engines::FieldsDict& dico) = 0;
    virtual FieldsDict* getProperties() = 0;
    virtual void SetOption(const char* optionName, const char* value) = 0;
    virtual char* GetOption(const char* optionName) = 0;
    virtual void Names(const char* aGraphName, const char* aNodeName) = 0;
    virtual ::CORBA::Boolean Kill_impl() = 0;
    virtual ::CORBA::Boolean Stop_impl() = 0;
    virtual ::CORBA::Boolean Suspend_impl() = 0;
    virtual ::CORBA::Boolean Resume_impl() = 0;
    virtual ::CORBA::Long CpuUsed_impl() = 0;
    virtual TMPFile* DumpPython(::CORBA::Object_ptr theStudy, ::CORBA::Boolean isPublished, ::CORBA::Boolean isMultiFile, ::CORBA::Boolean& isValidScript) = 0;
    virtual Salome_file_ptr getInputFileToService(const char* service_name, const char* Salome_file_name) = 0;
    virtual void checkInputFilesToService(const char* service_name) = 0;
    virtual Salome_file_ptr setInputFileToService(const char* service_name, const char* Salome_file_name) = 0;
    virtual Salome_file_ptr getOutputFileToService(const char* service_name, const char* Salome_file_name) = 0;
    virtual void checkOutputFilesToService(const char* service_name) = 0;
    virtual Salome_file_ptr setOutputFileToService(const char* service_name, const char* Salome_file_name) = 0;
    virtual ::CORBA::Boolean hasObjectInfo() = 0;
    virtual char* getObjectInfo(::CORBA::Long studyId, const char* entry) = 0;
    virtual char* instanceName() = 0;
    virtual char* interfaceName() = 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_EngineComponent;

#ifndef __Engines_mImportableComponent__
#define __Engines_mImportableComponent__

  class ImportableComponent;
  class _objref_ImportableComponent;
  class _impl_ImportableComponent;
  
  typedef _objref_ImportableComponent* ImportableComponent_ptr;
  typedef ImportableComponent_ptr ImportableComponentRef;

  class ImportableComponent_Helper {
  public:
    typedef ImportableComponent_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_ImportableComponent, ImportableComponent_Helper> ImportableComponent_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_ImportableComponent,ImportableComponent_Helper > ImportableComponent_out;

#endif

  // interface ImportableComponent
  class ImportableComponent {
  public:
    // Declarations for this interface type.
    typedef ImportableComponent_ptr _ptr_type;
    typedef ImportableComponent_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_ImportableComponent :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    SALOME::StringSeq* GetImportableFormats();
    ::CORBA::Boolean ImportDataAs(const char* format, ::SALOME::GenericObj_ptr exporter);

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

  protected:
    virtual ~_objref_ImportableComponent();

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

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

    friend class ImportableComponent;
  };

  class _pof_ImportableComponent : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_ImportableComponent() : _OMNI_NS(proxyObjectFactory)(ImportableComponent::_PD_repoId) {}
    virtual ~_pof_ImportableComponent();

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

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

    virtual SALOME::StringSeq* GetImportableFormats() = 0;
    virtual ::CORBA::Boolean ImportDataAs(const char* format, ::SALOME::GenericObj_ptr exporter) = 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_ImportableComponent;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_fileBlock;

  class fileBlock_var;

  class fileBlock : public _CORBA_Unbounded_Sequence_Octet {
  public:
    typedef fileBlock_var _var_type;
    inline fileBlock() {}
    inline fileBlock(const fileBlock& _s)
      : _CORBA_Unbounded_Sequence_Octet(_s) {}

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

  

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

  class fileBlock_out;

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

  

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

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

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

  

    fileBlock*& _data;

  private:
    fileBlock_out();
    fileBlock_out& operator=(const fileBlock_var&);
  };

#ifndef __Engines_mfileTransfer__
#define __Engines_mfileTransfer__

  class fileTransfer;
  class _objref_fileTransfer;
  class _impl_fileTransfer;
  
  typedef _objref_fileTransfer* fileTransfer_ptr;
  typedef fileTransfer_ptr fileTransferRef;

  class fileTransfer_Helper {
  public:
    typedef fileTransfer_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_fileTransfer, fileTransfer_Helper> fileTransfer_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_fileTransfer,fileTransfer_Helper > fileTransfer_out;

#endif

  // interface fileTransfer
  class fileTransfer {
  public:
    // Declarations for this interface type.
    typedef fileTransfer_ptr _ptr_type;
    typedef fileTransfer_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_fileTransfer :
    public virtual SALOME::_objref_GenericObj
  {
  public:
    ::CORBA::Long open(const char* fileName);
    ::CORBA::Long openW(const char* fileName);
    void close(::CORBA::Long fileId);
    fileBlock* getBlock(::CORBA::Long fileId);
    void putBlock(::CORBA::Long fileId, const ::Engines::fileBlock& block);

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

  protected:
    virtual ~_objref_fileTransfer();

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

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

    friend class fileTransfer;
  };

  class _pof_fileTransfer : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_fileTransfer() : _OMNI_NS(proxyObjectFactory)(fileTransfer::_PD_repoId) {}
    virtual ~_pof_fileTransfer();

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

  class _impl_fileTransfer :
    public virtual SALOME::_impl_GenericObj
  {
  public:
    virtual ~_impl_fileTransfer();

    virtual ::CORBA::Long open(const char* fileName) = 0;
    virtual ::CORBA::Long openW(const char* fileName) = 0;
    virtual void close(::CORBA::Long fileId) = 0;
    virtual fileBlock* getBlock(::CORBA::Long fileId) = 0;
    virtual void putBlock(::CORBA::Long fileId, const ::Engines::fileBlock& block) = 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_fileTransfer;

  struct file {
    typedef _CORBA_ConstrType_Variable_Var<file> _var_type;

    
    ::CORBA::String_member file_name;

    ::CORBA::String_member path;

    ::CORBA::String_member type;

    ::CORBA::String_member source_file_name;

    ::CORBA::String_member status;

    ::CORBA::Long node;

    _CORBA_ObjRef_Member< Engines::_objref_Container, Engines::Container_Helper>  container;

  

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

  typedef file::_var_type file_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< file,file_var > file_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_file;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_files;

  class files_var;

  class files : public _CORBA_Unbounded_Sequence< file >  {
  public:
    typedef files_var _var_type;
    inline files() {}
    inline files(const files& _s)
      : _CORBA_Unbounded_Sequence< file > (_s) {}

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

  

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

  class files_out;

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

  

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

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

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

  

    files*& _data;

  private:
    files_out();
    files_out& operator=(const files_var&);
  };

  struct SfState {
    typedef _CORBA_ConstrType_Variable_Var<SfState> _var_type;

    
    ::CORBA::String_member name;

    ::CORBA::String_member hdf5_file_name;

    ::CORBA::Long number_of_files;

    ::CORBA::Boolean files_ok;

  

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

  typedef SfState::_var_type SfState_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< SfState,SfState_var > SfState_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_SfState;

#ifndef __Engines_mSalome__file__
#define __Engines_mSalome__file__

  class Salome_file;
  class _objref_Salome_file;
  class _impl_Salome_file;
  
  typedef _objref_Salome_file* Salome_file_ptr;
  typedef Salome_file_ptr Salome_fileRef;

  class Salome_file_Helper {
  public:
    typedef Salome_file_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_Salome_file, Salome_file_Helper> Salome_file_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Salome_file,Salome_file_Helper > Salome_file_out;

#endif

  // interface Salome_file
  class Salome_file {
  public:
    // Declarations for this interface type.
    typedef Salome_file_ptr _ptr_type;
    typedef Salome_file_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_Salome_file :
    public virtual _objref_fileTransfer
  {
  public:
    void load(const char* hdf5_file);
    void save(const char* hdf5_file);
    void save_all(const char* hdf5_file);
    void setLocalFile(const char* comp_file_name);
    void setDistributedFile(const char* comp_file_name);
    void connect(::Engines::Salome_file_ptr source_Salome_file);
    void connectDistributedFile(const char* file_name, ::Engines::Salome_file_ptr source_Salome_file);
    void setDistributedSourceFile(const char* file_name, const char* source_file_name);
    void recvFiles();
    void removeFile(const char* file_name);
    void removeFiles();
    files* getFilesInfos();
    file* getFileInfos(const char* file_name);
    SfState* getSalome_fileState();
    void setContainer(::Engines::Container_ptr container);

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

  protected:
    virtual ~_objref_Salome_file();

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

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

    friend class Salome_file;
  };

  class _pof_Salome_file : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Salome_file() : _OMNI_NS(proxyObjectFactory)(Salome_file::_PD_repoId) {}
    virtual ~_pof_Salome_file();

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

  class _impl_Salome_file :
    public virtual _impl_fileTransfer
  {
  public:
    virtual ~_impl_Salome_file();

    virtual void load(const char* hdf5_file) = 0;
    virtual void save(const char* hdf5_file) = 0;
    virtual void save_all(const char* hdf5_file) = 0;
    virtual void setLocalFile(const char* comp_file_name) = 0;
    virtual void setDistributedFile(const char* comp_file_name) = 0;
    virtual void connect(::Engines::Salome_file_ptr source_Salome_file) = 0;
    virtual void connectDistributedFile(const char* file_name, ::Engines::Salome_file_ptr source_Salome_file) = 0;
    virtual void setDistributedSourceFile(const char* file_name, const char* source_file_name) = 0;
    virtual void recvFiles() = 0;
    virtual void removeFile(const char* file_name) = 0;
    virtual void removeFiles() = 0;
    virtual files* getFilesInfos() = 0;
    virtual file* getFileInfos(const char* file_name) = 0;
    virtual SfState* getSalome_fileState() = 0;
    virtual void setContainer(::Engines::Container_ptr container) = 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_Salome_file;

#ifndef __Engines_mfileRef__
#define __Engines_mfileRef__

  class fileRef;
  class _objref_fileRef;
  class _impl_fileRef;
  
  typedef _objref_fileRef* fileRef_ptr;
  typedef fileRef_ptr fileRefRef;

  class fileRef_Helper {
  public:
    typedef fileRef_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_fileRef, fileRef_Helper> fileRef_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_fileRef,fileRef_Helper > fileRef_out;

#endif

  // interface fileRef
  class fileRef {
  public:
    // Declarations for this interface type.
    typedef fileRef_ptr _ptr_type;
    typedef fileRef_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_fileRef :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    Container_ptr getContainer();
    ::CORBA::Boolean addRef(const char* machine, const char* fileName);
    char* getRef(const char* machine);
    char* origFileName();
    char* refMachine();

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

  protected:
    virtual ~_objref_fileRef();

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

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

    friend class fileRef;
  };

  class _pof_fileRef : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_fileRef() : _OMNI_NS(proxyObjectFactory)(fileRef::_PD_repoId) {}
    virtual ~_pof_fileRef();

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

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

    virtual Container_ptr getContainer() = 0;
    virtual ::CORBA::Boolean addRef(const char* machine, const char* fileName) = 0;
    virtual char* getRef(const char* machine) = 0;
    virtual char* origFileName() = 0;
    virtual char* refMachine() = 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_fileRef;

_CORBA_MODULE_END



_CORBA_MODULE POA_Engines
_CORBA_MODULE_BEG

  class Container :
    public virtual Engines::_impl_Container,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~Container();

    inline ::Engines::Container_ptr _this() {
      return (::Engines::Container_ptr) _do_this(::Engines::Container::_PD_repoId);
    }
  };

  class EngineComponent :
    public virtual Engines::_impl_EngineComponent,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~EngineComponent();

    inline ::Engines::EngineComponent_ptr _this() {
      return (::Engines::EngineComponent_ptr) _do_this(::Engines::EngineComponent::_PD_repoId);
    }
  };

  class ImportableComponent :
    public virtual Engines::_impl_ImportableComponent,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~ImportableComponent();

    inline ::Engines::ImportableComponent_ptr _this() {
      return (::Engines::ImportableComponent_ptr) _do_this(::Engines::ImportableComponent::_PD_repoId);
    }
  };

  class fileTransfer :
    public virtual Engines::_impl_fileTransfer,
    public virtual POA_SALOME::GenericObj
  {
  public:
    virtual ~fileTransfer();

    inline ::Engines::fileTransfer_ptr _this() {
      return (::Engines::fileTransfer_ptr) _do_this(::Engines::fileTransfer::_PD_repoId);
    }
  };

  class Salome_file :
    public virtual Engines::_impl_Salome_file,
    public virtual fileTransfer
  {
  public:
    virtual ~Salome_file();

    inline ::Engines::Salome_file_ptr _this() {
      return (::Engines::Salome_file_ptr) _do_this(::Engines::Salome_file::_PD_repoId);
    }
  };

  class fileRef :
    public virtual Engines::_impl_fileRef,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~fileRef();

    inline ::Engines::fileRef_ptr _this() {
      return (::Engines::fileRef_ptr) _do_this(::Engines::fileRef::_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::TMPFile& _s);
void operator<<=(::CORBA::Any& _a, Engines::TMPFile* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Engines::TMPFile*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Engines::TMPFile*& _sp);

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

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

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

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

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

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

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

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

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

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

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

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

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



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


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


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


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


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


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




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_SALOME__Component
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_SALOME__Component
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__Component
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__Component
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__Component
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__Component
#endif

#endif  // __SALOME__Component_hh__
salome-kernel-dev 6.5.0-7ubuntu2 / usr / include / salome / SALOME_Component.hh
