salome-kernel-dev 6.5.0-7ubuntu2 / usr / include / salome / SALOME_Comm.hh

// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __SALOME__Comm_hh__
#define __SALOME__Comm_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__Comm
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__Comm
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__Comm
#endif



#ifndef __SALOME__Exception_hh_EXTERNAL_GUARD__
#define __SALOME__Exception_hh_EXTERNAL_GUARD__
#include <SALOME_Exception.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 SALOME

_CORBA_MODULE_BEG

  enum TypeOfDataTransmitted { DOUBLE_, INT_ /*, __max_TypeOfDataTransmitted=0xffffffff */ };
  typedef TypeOfDataTransmitted& TypeOfDataTransmitted_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_TypeOfDataTransmitted;

  enum TypeOfCommunication { CORBA_, MPI_, SOCKET_ /*, __max_TypeOfCommunication=0xffffffff */ };
  typedef TypeOfCommunication& TypeOfCommunication_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_TypeOfCommunication;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_vectorOfDouble;

  class vectorOfDouble_var;

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

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

  

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

  class vectorOfDouble_out;

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

  

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

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

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

  

    vectorOfDouble*& _data;

  private:
    vectorOfDouble_out();
    vectorOfDouble_out& operator=(const vectorOfDouble_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_vectorOfLong;

  class vectorOfLong_var;

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

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

  

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

  class vectorOfLong_out;

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

  

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

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

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

  

    vectorOfLong*& _data;

  private:
    vectorOfLong_out();
    vectorOfLong_out& operator=(const vectorOfLong_var&);
  };

#ifndef __SALOME_mMultiCommClass__
#define __SALOME_mMultiCommClass__

  class MultiCommClass;
  class _objref_MultiCommClass;
  class _impl_MultiCommClass;
  
  typedef _objref_MultiCommClass* MultiCommClass_ptr;
  typedef MultiCommClass_ptr MultiCommClassRef;

  class MultiCommClass_Helper {
  public:
    typedef MultiCommClass_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_MultiCommClass, MultiCommClass_Helper> MultiCommClass_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_MultiCommClass,MultiCommClass_Helper > MultiCommClass_out;

#endif

  // interface MultiCommClass
  class MultiCommClass {
  public:
    // Declarations for this interface type.
    typedef MultiCommClass_ptr _ptr_type;
    typedef MultiCommClass_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_MultiCommClass :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    void setProtocol(::SALOME::TypeOfCommunication typ);

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

  protected:
    virtual ~_objref_MultiCommClass();

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

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

    friend class MultiCommClass;
  };

  class _pof_MultiCommClass : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_MultiCommClass() : _OMNI_NS(proxyObjectFactory)(MultiCommClass::_PD_repoId) {}
    virtual ~_pof_MultiCommClass();

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

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

    virtual void setProtocol(::SALOME::TypeOfCommunication typ) = 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_MultiCommClass;

#ifndef __SALOME_mServantLifeCycle__
#define __SALOME_mServantLifeCycle__

  class ServantLifeCycle;
  class _objref_ServantLifeCycle;
  class _impl_ServantLifeCycle;
  
  typedef _objref_ServantLifeCycle* ServantLifeCycle_ptr;
  typedef ServantLifeCycle_ptr ServantLifeCycleRef;

  class ServantLifeCycle_Helper {
  public:
    typedef ServantLifeCycle_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_ServantLifeCycle, ServantLifeCycle_Helper> ServantLifeCycle_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_ServantLifeCycle,ServantLifeCycle_Helper > ServantLifeCycle_out;

#endif

  // interface ServantLifeCycle
  class ServantLifeCycle {
  public:
    // Declarations for this interface type.
    typedef ServantLifeCycle_ptr _ptr_type;
    typedef ServantLifeCycle_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_ServantLifeCycle :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    void release();

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

  protected:
    virtual ~_objref_ServantLifeCycle();

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

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

    friend class ServantLifeCycle;
  };

  class _pof_ServantLifeCycle : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_ServantLifeCycle() : _OMNI_NS(proxyObjectFactory)(ServantLifeCycle::_PD_repoId) {}
    virtual ~_pof_ServantLifeCycle();

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

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

    virtual void release() = 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_ServantLifeCycle;

#ifndef __SALOME_mSender__
#define __SALOME_mSender__

  class Sender;
  class _objref_Sender;
  class _impl_Sender;
  
  typedef _objref_Sender* Sender_ptr;
  typedef Sender_ptr SenderRef;

  class Sender_Helper {
  public:
    typedef Sender_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_Sender, Sender_Helper> Sender_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Sender,Sender_Helper > Sender_out;

#endif

  // interface Sender
  class Sender {
  public:
    // Declarations for this interface type.
    typedef Sender_ptr _ptr_type;
    typedef Sender_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_Sender :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    TypeOfDataTransmitted getTypeOfDataTransmitted();
    void release();

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

  protected:
    virtual ~_objref_Sender();

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

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

    friend class Sender;
  };

  class _pof_Sender : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Sender() : _OMNI_NS(proxyObjectFactory)(Sender::_PD_repoId) {}
    virtual ~_pof_Sender();

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

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

    virtual TypeOfDataTransmitted getTypeOfDataTransmitted() = 0;
    virtual void release() = 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_Sender;

#ifndef __SALOME_mSenderDouble__
#define __SALOME_mSenderDouble__

  class SenderDouble;
  class _objref_SenderDouble;
  class _impl_SenderDouble;
  
  typedef _objref_SenderDouble* SenderDouble_ptr;
  typedef SenderDouble_ptr SenderDoubleRef;

  class SenderDouble_Helper {
  public:
    typedef SenderDouble_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_SenderDouble, SenderDouble_Helper> SenderDouble_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SenderDouble,SenderDouble_Helper > SenderDouble_out;

#endif

  // interface SenderDouble
  class SenderDouble {
  public:
    // Declarations for this interface type.
    typedef SenderDouble_ptr _ptr_type;
    typedef SenderDouble_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_SenderDouble :
    public virtual _objref_Sender
  {
  public:
    SenderDouble_ptr buildOtherWithProtocol(::SALOME::TypeOfCommunication type);

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

  protected:
    virtual ~_objref_SenderDouble();

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

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

    friend class SenderDouble;
  };

  class _pof_SenderDouble : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SenderDouble() : _OMNI_NS(proxyObjectFactory)(SenderDouble::_PD_repoId) {}
    virtual ~_pof_SenderDouble();

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

  class _impl_SenderDouble :
    public virtual _impl_Sender
  {
  public:
    virtual ~_impl_SenderDouble();

    virtual SenderDouble_ptr buildOtherWithProtocol(::SALOME::TypeOfCommunication type) = 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_SenderDouble;

#ifndef __SALOME_mSenderInt__
#define __SALOME_mSenderInt__

  class SenderInt;
  class _objref_SenderInt;
  class _impl_SenderInt;
  
  typedef _objref_SenderInt* SenderInt_ptr;
  typedef SenderInt_ptr SenderIntRef;

  class SenderInt_Helper {
  public:
    typedef SenderInt_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_SenderInt, SenderInt_Helper> SenderInt_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SenderInt,SenderInt_Helper > SenderInt_out;

#endif

  // interface SenderInt
  class SenderInt {
  public:
    // Declarations for this interface type.
    typedef SenderInt_ptr _ptr_type;
    typedef SenderInt_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_SenderInt :
    public virtual _objref_Sender
  {
  public:
    SenderInt_ptr buildOtherWithProtocol(::SALOME::TypeOfCommunication type);

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

  protected:
    virtual ~_objref_SenderInt();

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

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

    friend class SenderInt;
  };

  class _pof_SenderInt : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SenderInt() : _OMNI_NS(proxyObjectFactory)(SenderInt::_PD_repoId) {}
    virtual ~_pof_SenderInt();

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

  class _impl_SenderInt :
    public virtual _impl_Sender
  {
  public:
    virtual ~_impl_SenderInt();

    virtual SenderInt_ptr buildOtherWithProtocol(::SALOME::TypeOfCommunication type) = 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_SenderInt;

#ifndef __SALOME_mCorbaDoubleNCSender__
#define __SALOME_mCorbaDoubleNCSender__

  class CorbaDoubleNCSender;
  class _objref_CorbaDoubleNCSender;
  class _impl_CorbaDoubleNCSender;
  
  typedef _objref_CorbaDoubleNCSender* CorbaDoubleNCSender_ptr;
  typedef CorbaDoubleNCSender_ptr CorbaDoubleNCSenderRef;

  class CorbaDoubleNCSender_Helper {
  public:
    typedef CorbaDoubleNCSender_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_CorbaDoubleNCSender, CorbaDoubleNCSender_Helper> CorbaDoubleNCSender_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_CorbaDoubleNCSender,CorbaDoubleNCSender_Helper > CorbaDoubleNCSender_out;

#endif

  // interface CorbaDoubleNCSender
  class CorbaDoubleNCSender {
  public:
    // Declarations for this interface type.
    typedef CorbaDoubleNCSender_ptr _ptr_type;
    typedef CorbaDoubleNCSender_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_CorbaDoubleNCSender :
    public virtual _objref_SenderDouble
  {
  public:
    ::CORBA::ULong getSize();
    vectorOfDouble* sendPart(::CORBA::ULong n1, ::CORBA::ULong n2);
    vectorOfDouble* send();

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

  protected:
    virtual ~_objref_CorbaDoubleNCSender();

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

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

    friend class CorbaDoubleNCSender;
  };

  class _pof_CorbaDoubleNCSender : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_CorbaDoubleNCSender() : _OMNI_NS(proxyObjectFactory)(CorbaDoubleNCSender::_PD_repoId) {}
    virtual ~_pof_CorbaDoubleNCSender();

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

  class _impl_CorbaDoubleNCSender :
    public virtual _impl_SenderDouble
  {
  public:
    virtual ~_impl_CorbaDoubleNCSender();

    virtual ::CORBA::ULong getSize() = 0;
    virtual vectorOfDouble* sendPart(::CORBA::ULong n1, ::CORBA::ULong n2) = 0;
    virtual vectorOfDouble* send() = 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_CorbaDoubleNCSender;

#ifndef __SALOME_mCorbaDoubleCSender__
#define __SALOME_mCorbaDoubleCSender__

  class CorbaDoubleCSender;
  class _objref_CorbaDoubleCSender;
  class _impl_CorbaDoubleCSender;
  
  typedef _objref_CorbaDoubleCSender* CorbaDoubleCSender_ptr;
  typedef CorbaDoubleCSender_ptr CorbaDoubleCSenderRef;

  class CorbaDoubleCSender_Helper {
  public:
    typedef CorbaDoubleCSender_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_CorbaDoubleCSender, CorbaDoubleCSender_Helper> CorbaDoubleCSender_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_CorbaDoubleCSender,CorbaDoubleCSender_Helper > CorbaDoubleCSender_out;

#endif

  // interface CorbaDoubleCSender
  class CorbaDoubleCSender {
  public:
    // Declarations for this interface type.
    typedef CorbaDoubleCSender_ptr _ptr_type;
    typedef CorbaDoubleCSender_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_CorbaDoubleCSender :
    public virtual _objref_SenderDouble
  {
  public:
    ::CORBA::ULong getSize();
    vectorOfDouble* sendPart(::CORBA::ULong n1, ::CORBA::ULong n2);

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

  protected:
    virtual ~_objref_CorbaDoubleCSender();

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

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

    friend class CorbaDoubleCSender;
  };

  class _pof_CorbaDoubleCSender : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_CorbaDoubleCSender() : _OMNI_NS(proxyObjectFactory)(CorbaDoubleCSender::_PD_repoId) {}
    virtual ~_pof_CorbaDoubleCSender();

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

  class _impl_CorbaDoubleCSender :
    public virtual _impl_SenderDouble
  {
  public:
    virtual ~_impl_CorbaDoubleCSender();

    virtual ::CORBA::ULong getSize() = 0;
    virtual vectorOfDouble* sendPart(::CORBA::ULong n1, ::CORBA::ULong n2) = 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_CorbaDoubleCSender;

#ifndef __SALOME_mCorbaLongNCSender__
#define __SALOME_mCorbaLongNCSender__

  class CorbaLongNCSender;
  class _objref_CorbaLongNCSender;
  class _impl_CorbaLongNCSender;
  
  typedef _objref_CorbaLongNCSender* CorbaLongNCSender_ptr;
  typedef CorbaLongNCSender_ptr CorbaLongNCSenderRef;

  class CorbaLongNCSender_Helper {
  public:
    typedef CorbaLongNCSender_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_CorbaLongNCSender, CorbaLongNCSender_Helper> CorbaLongNCSender_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_CorbaLongNCSender,CorbaLongNCSender_Helper > CorbaLongNCSender_out;

#endif

  // interface CorbaLongNCSender
  class CorbaLongNCSender {
  public:
    // Declarations for this interface type.
    typedef CorbaLongNCSender_ptr _ptr_type;
    typedef CorbaLongNCSender_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_CorbaLongNCSender :
    public virtual _objref_SenderInt
  {
  public:
    ::CORBA::ULong getSize();
    vectorOfLong* sendPart(::CORBA::ULong n1, ::CORBA::ULong n2);
    vectorOfLong* send();

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

  protected:
    virtual ~_objref_CorbaLongNCSender();

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

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

    friend class CorbaLongNCSender;
  };

  class _pof_CorbaLongNCSender : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_CorbaLongNCSender() : _OMNI_NS(proxyObjectFactory)(CorbaLongNCSender::_PD_repoId) {}
    virtual ~_pof_CorbaLongNCSender();

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

  class _impl_CorbaLongNCSender :
    public virtual _impl_SenderInt
  {
  public:
    virtual ~_impl_CorbaLongNCSender();

    virtual ::CORBA::ULong getSize() = 0;
    virtual vectorOfLong* sendPart(::CORBA::ULong n1, ::CORBA::ULong n2) = 0;
    virtual vectorOfLong* send() = 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_CorbaLongNCSender;

#ifndef __SALOME_mCorbaLongCSender__
#define __SALOME_mCorbaLongCSender__

  class CorbaLongCSender;
  class _objref_CorbaLongCSender;
  class _impl_CorbaLongCSender;
  
  typedef _objref_CorbaLongCSender* CorbaLongCSender_ptr;
  typedef CorbaLongCSender_ptr CorbaLongCSenderRef;

  class CorbaLongCSender_Helper {
  public:
    typedef CorbaLongCSender_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_CorbaLongCSender, CorbaLongCSender_Helper> CorbaLongCSender_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_CorbaLongCSender,CorbaLongCSender_Helper > CorbaLongCSender_out;

#endif

  // interface CorbaLongCSender
  class CorbaLongCSender {
  public:
    // Declarations for this interface type.
    typedef CorbaLongCSender_ptr _ptr_type;
    typedef CorbaLongCSender_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_CorbaLongCSender :
    public virtual _objref_SenderInt
  {
  public:
    ::CORBA::ULong getSize();
    vectorOfLong* sendPart(::CORBA::ULong n1, ::CORBA::ULong n2);

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

  protected:
    virtual ~_objref_CorbaLongCSender();

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

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

    friend class CorbaLongCSender;
  };

  class _pof_CorbaLongCSender : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_CorbaLongCSender() : _OMNI_NS(proxyObjectFactory)(CorbaLongCSender::_PD_repoId) {}
    virtual ~_pof_CorbaLongCSender();

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

  class _impl_CorbaLongCSender :
    public virtual _impl_SenderInt
  {
  public:
    virtual ~_impl_CorbaLongCSender();

    virtual ::CORBA::ULong getSize() = 0;
    virtual vectorOfLong* sendPart(::CORBA::ULong n1, ::CORBA::ULong n2) = 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_CorbaLongCSender;

#ifndef __SALOME_mMPISender__
#define __SALOME_mMPISender__

  class MPISender;
  class _objref_MPISender;
  class _impl_MPISender;
  
  typedef _objref_MPISender* MPISender_ptr;
  typedef MPISender_ptr MPISenderRef;

  class MPISender_Helper {
  public:
    typedef MPISender_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_MPISender, MPISender_Helper> MPISender_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_MPISender,MPISender_Helper > MPISender_out;

#endif

  // interface MPISender
  class MPISender {
  public:
    // Declarations for this interface type.
    typedef MPISender_ptr _ptr_type;
    typedef MPISender_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.
    struct Parameter {
      typedef _CORBA_ConstrType_Variable_Var<Parameter> _var_type;

      
      ::CORBA::ULong myproc;

      ::CORBA::ULong tag1;

      ::CORBA::ULong tag2;

      ::CORBA::String_member service;

    

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

    typedef Parameter::_var_type Parameter_var;

    typedef _CORBA_ConstrType_Variable_OUT_arg< Parameter,Parameter_var > Parameter_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_Parameter;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_param;

    typedef Parameter param;
    typedef Parameter_var param_var;
    typedef Parameter_out param_out;

  
  };

  class _objref_MPISender :
    public virtual _objref_Sender
  {
  public:
    MPISender::param* getParam();
    void send();
    void close(const ::SALOME::MPISender::param& p);

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

  protected:
    virtual ~_objref_MPISender();

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

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

    friend class MPISender;
  };

  class _pof_MPISender : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_MPISender() : _OMNI_NS(proxyObjectFactory)(MPISender::_PD_repoId) {}
    virtual ~_pof_MPISender();

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

  class _impl_MPISender :
    public virtual _impl_Sender
  {
  public:
    virtual ~_impl_MPISender();

    virtual MPISender::param* getParam() = 0;
    virtual void send() = 0;
    virtual void close(const ::SALOME::MPISender::param& p) = 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_MPISender;

#ifndef __SALOME_mMPISenderDouble__
#define __SALOME_mMPISenderDouble__

  class MPISenderDouble;
  class _objref_MPISenderDouble;
  class _impl_MPISenderDouble;
  
  typedef _objref_MPISenderDouble* MPISenderDouble_ptr;
  typedef MPISenderDouble_ptr MPISenderDoubleRef;

  class MPISenderDouble_Helper {
  public:
    typedef MPISenderDouble_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_MPISenderDouble, MPISenderDouble_Helper> MPISenderDouble_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_MPISenderDouble,MPISenderDouble_Helper > MPISenderDouble_out;

#endif

  // interface MPISenderDouble
  class MPISenderDouble {
  public:
    // Declarations for this interface type.
    typedef MPISenderDouble_ptr _ptr_type;
    typedef MPISenderDouble_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_MPISenderDouble :
    public virtual _objref_SenderDouble,
    public virtual _objref_MPISender
  {
  public:
    

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

  protected:
    virtual ~_objref_MPISenderDouble();

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

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

    friend class MPISenderDouble;
  };

  class _pof_MPISenderDouble : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_MPISenderDouble() : _OMNI_NS(proxyObjectFactory)(MPISenderDouble::_PD_repoId) {}
    virtual ~_pof_MPISenderDouble();

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

  class _impl_MPISenderDouble :
    public virtual _impl_SenderDouble,
    public virtual _impl_MPISender
  {
  public:
    virtual ~_impl_MPISenderDouble();

    
    
  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_MPISenderDouble;

#ifndef __SALOME_mMPISenderInt__
#define __SALOME_mMPISenderInt__

  class MPISenderInt;
  class _objref_MPISenderInt;
  class _impl_MPISenderInt;
  
  typedef _objref_MPISenderInt* MPISenderInt_ptr;
  typedef MPISenderInt_ptr MPISenderIntRef;

  class MPISenderInt_Helper {
  public:
    typedef MPISenderInt_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_MPISenderInt, MPISenderInt_Helper> MPISenderInt_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_MPISenderInt,MPISenderInt_Helper > MPISenderInt_out;

#endif

  // interface MPISenderInt
  class MPISenderInt {
  public:
    // Declarations for this interface type.
    typedef MPISenderInt_ptr _ptr_type;
    typedef MPISenderInt_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_MPISenderInt :
    public virtual _objref_SenderInt,
    public virtual _objref_MPISender
  {
  public:
    

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

  protected:
    virtual ~_objref_MPISenderInt();

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

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

    friend class MPISenderInt;
  };

  class _pof_MPISenderInt : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_MPISenderInt() : _OMNI_NS(proxyObjectFactory)(MPISenderInt::_PD_repoId) {}
    virtual ~_pof_MPISenderInt();

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

  class _impl_MPISenderInt :
    public virtual _impl_SenderInt,
    public virtual _impl_MPISender
  {
  public:
    virtual ~_impl_MPISenderInt();

    
    
  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_MPISenderInt;

#ifndef __SALOME_mSocketSender__
#define __SALOME_mSocketSender__

  class SocketSender;
  class _objref_SocketSender;
  class _impl_SocketSender;
  
  typedef _objref_SocketSender* SocketSender_ptr;
  typedef SocketSender_ptr SocketSenderRef;

  class SocketSender_Helper {
  public:
    typedef SocketSender_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_SocketSender, SocketSender_Helper> SocketSender_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SocketSender,SocketSender_Helper > SocketSender_out;

#endif

  // interface SocketSender
  class SocketSender {
  public:
    // Declarations for this interface type.
    typedef SocketSender_ptr _ptr_type;
    typedef SocketSender_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.
    struct Parameter {
      typedef _CORBA_ConstrType_Variable_Var<Parameter> _var_type;

      
      ::CORBA::ULong lstart;

      ::CORBA::ULong lend;

      ::CORBA::ULong myport;

      ::CORBA::String_member internet_address;

    

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

    typedef Parameter::_var_type Parameter_var;

    typedef _CORBA_ConstrType_Variable_OUT_arg< Parameter,Parameter_var > Parameter_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_Parameter;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_param;

    typedef Parameter param;
    typedef Parameter_var param_var;
    typedef Parameter_out param_out;

  
  };

  class _objref_SocketSender :
    public virtual _objref_Sender
  {
  public:
    SocketSender::param* getParam();
    void initCom();
    void acceptCom();
    void closeCom();
    void endOfCom();
    void send();

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

  protected:
    virtual ~_objref_SocketSender();

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

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

    friend class SocketSender;
  };

  class _pof_SocketSender : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SocketSender() : _OMNI_NS(proxyObjectFactory)(SocketSender::_PD_repoId) {}
    virtual ~_pof_SocketSender();

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

  class _impl_SocketSender :
    public virtual _impl_Sender
  {
  public:
    virtual ~_impl_SocketSender();

    virtual SocketSender::param* getParam() = 0;
    virtual void initCom() = 0;
    virtual void acceptCom() = 0;
    virtual void closeCom() = 0;
    virtual void endOfCom() = 0;
    virtual void send() = 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_SocketSender;

#ifndef __SALOME_mSocketSenderDouble__
#define __SALOME_mSocketSenderDouble__

  class SocketSenderDouble;
  class _objref_SocketSenderDouble;
  class _impl_SocketSenderDouble;
  
  typedef _objref_SocketSenderDouble* SocketSenderDouble_ptr;
  typedef SocketSenderDouble_ptr SocketSenderDoubleRef;

  class SocketSenderDouble_Helper {
  public:
    typedef SocketSenderDouble_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_SocketSenderDouble, SocketSenderDouble_Helper> SocketSenderDouble_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SocketSenderDouble,SocketSenderDouble_Helper > SocketSenderDouble_out;

#endif

  // interface SocketSenderDouble
  class SocketSenderDouble {
  public:
    // Declarations for this interface type.
    typedef SocketSenderDouble_ptr _ptr_type;
    typedef SocketSenderDouble_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_SocketSenderDouble :
    public virtual _objref_SenderDouble,
    public virtual _objref_SocketSender
  {
  public:
    

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

  protected:
    virtual ~_objref_SocketSenderDouble();

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

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

    friend class SocketSenderDouble;
  };

  class _pof_SocketSenderDouble : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SocketSenderDouble() : _OMNI_NS(proxyObjectFactory)(SocketSenderDouble::_PD_repoId) {}
    virtual ~_pof_SocketSenderDouble();

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

  class _impl_SocketSenderDouble :
    public virtual _impl_SenderDouble,
    public virtual _impl_SocketSender
  {
  public:
    virtual ~_impl_SocketSenderDouble();

    
    
  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_SocketSenderDouble;

#ifndef __SALOME_mSocketSenderInt__
#define __SALOME_mSocketSenderInt__

  class SocketSenderInt;
  class _objref_SocketSenderInt;
  class _impl_SocketSenderInt;
  
  typedef _objref_SocketSenderInt* SocketSenderInt_ptr;
  typedef SocketSenderInt_ptr SocketSenderIntRef;

  class SocketSenderInt_Helper {
  public:
    typedef SocketSenderInt_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_SocketSenderInt, SocketSenderInt_Helper> SocketSenderInt_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SocketSenderInt,SocketSenderInt_Helper > SocketSenderInt_out;

#endif

  // interface SocketSenderInt
  class SocketSenderInt {
  public:
    // Declarations for this interface type.
    typedef SocketSenderInt_ptr _ptr_type;
    typedef SocketSenderInt_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_SocketSenderInt :
    public virtual _objref_SenderInt,
    public virtual _objref_SocketSender
  {
  public:
    

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

  protected:
    virtual ~_objref_SocketSenderInt();

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

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

    friend class SocketSenderInt;
  };

  class _pof_SocketSenderInt : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SocketSenderInt() : _OMNI_NS(proxyObjectFactory)(SocketSenderInt::_PD_repoId) {}
    virtual ~_pof_SocketSenderInt();

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

  class _impl_SocketSenderInt :
    public virtual _impl_SenderInt,
    public virtual _impl_SocketSender
  {
  public:
    virtual ~_impl_SocketSenderInt();

    
    
  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_SocketSenderInt;

#ifndef __SALOME_mMatrix__
#define __SALOME_mMatrix__

  class Matrix;
  class _objref_Matrix;
  class _impl_Matrix;
  
  typedef _objref_Matrix* Matrix_ptr;
  typedef Matrix_ptr MatrixRef;

  class Matrix_Helper {
  public:
    typedef Matrix_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_Matrix, Matrix_Helper> Matrix_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Matrix,Matrix_Helper > Matrix_out;

#endif

  // interface Matrix
  class Matrix {
  public:
    // Declarations for this interface type.
    typedef Matrix_ptr _ptr_type;
    typedef Matrix_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_Matrix :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    SenderDouble_ptr getData();
    ::CORBA::Long getSizeOfColumn();
    void release();

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

  protected:
    virtual ~_objref_Matrix();

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

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

    friend class Matrix;
  };

  class _pof_Matrix : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Matrix() : _OMNI_NS(proxyObjectFactory)(Matrix::_PD_repoId) {}
    virtual ~_pof_Matrix();

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

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

    virtual SenderDouble_ptr getData() = 0;
    virtual ::CORBA::Long getSizeOfColumn() = 0;
    virtual void release() = 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_Matrix;

_CORBA_MODULE_END



_CORBA_MODULE POA_SALOME
_CORBA_MODULE_BEG

  class MultiCommClass :
    public virtual SALOME::_impl_MultiCommClass,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~MultiCommClass();

    inline ::SALOME::MultiCommClass_ptr _this() {
      return (::SALOME::MultiCommClass_ptr) _do_this(::SALOME::MultiCommClass::_PD_repoId);
    }
  };

  class ServantLifeCycle :
    public virtual SALOME::_impl_ServantLifeCycle,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~ServantLifeCycle();

    inline ::SALOME::ServantLifeCycle_ptr _this() {
      return (::SALOME::ServantLifeCycle_ptr) _do_this(::SALOME::ServantLifeCycle::_PD_repoId);
    }
  };

  class Sender :
    public virtual SALOME::_impl_Sender,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~Sender();

    inline ::SALOME::Sender_ptr _this() {
      return (::SALOME::Sender_ptr) _do_this(::SALOME::Sender::_PD_repoId);
    }
  };

  class SenderDouble :
    public virtual SALOME::_impl_SenderDouble,
    public virtual Sender
  {
  public:
    virtual ~SenderDouble();

    inline ::SALOME::SenderDouble_ptr _this() {
      return (::SALOME::SenderDouble_ptr) _do_this(::SALOME::SenderDouble::_PD_repoId);
    }
  };

  class SenderInt :
    public virtual SALOME::_impl_SenderInt,
    public virtual Sender
  {
  public:
    virtual ~SenderInt();

    inline ::SALOME::SenderInt_ptr _this() {
      return (::SALOME::SenderInt_ptr) _do_this(::SALOME::SenderInt::_PD_repoId);
    }
  };

  class CorbaDoubleNCSender :
    public virtual SALOME::_impl_CorbaDoubleNCSender,
    public virtual SenderDouble
  {
  public:
    virtual ~CorbaDoubleNCSender();

    inline ::SALOME::CorbaDoubleNCSender_ptr _this() {
      return (::SALOME::CorbaDoubleNCSender_ptr) _do_this(::SALOME::CorbaDoubleNCSender::_PD_repoId);
    }
  };

  class CorbaDoubleCSender :
    public virtual SALOME::_impl_CorbaDoubleCSender,
    public virtual SenderDouble
  {
  public:
    virtual ~CorbaDoubleCSender();

    inline ::SALOME::CorbaDoubleCSender_ptr _this() {
      return (::SALOME::CorbaDoubleCSender_ptr) _do_this(::SALOME::CorbaDoubleCSender::_PD_repoId);
    }
  };

  class CorbaLongNCSender :
    public virtual SALOME::_impl_CorbaLongNCSender,
    public virtual SenderInt
  {
  public:
    virtual ~CorbaLongNCSender();

    inline ::SALOME::CorbaLongNCSender_ptr _this() {
      return (::SALOME::CorbaLongNCSender_ptr) _do_this(::SALOME::CorbaLongNCSender::_PD_repoId);
    }
  };

  class CorbaLongCSender :
    public virtual SALOME::_impl_CorbaLongCSender,
    public virtual SenderInt
  {
  public:
    virtual ~CorbaLongCSender();

    inline ::SALOME::CorbaLongCSender_ptr _this() {
      return (::SALOME::CorbaLongCSender_ptr) _do_this(::SALOME::CorbaLongCSender::_PD_repoId);
    }
  };

  class MPISender :
    public virtual SALOME::_impl_MPISender,
    public virtual Sender
  {
  public:
    virtual ~MPISender();

    inline ::SALOME::MPISender_ptr _this() {
      return (::SALOME::MPISender_ptr) _do_this(::SALOME::MPISender::_PD_repoId);
    }
  };

  class MPISenderDouble :
    public virtual SALOME::_impl_MPISenderDouble,
    public virtual SenderDouble,
      public virtual MPISender
  {
  public:
    virtual ~MPISenderDouble();

    inline ::SALOME::MPISenderDouble_ptr _this() {
      return (::SALOME::MPISenderDouble_ptr) _do_this(::SALOME::MPISenderDouble::_PD_repoId);
    }
  };

  class MPISenderInt :
    public virtual SALOME::_impl_MPISenderInt,
    public virtual SenderInt,
      public virtual MPISender
  {
  public:
    virtual ~MPISenderInt();

    inline ::SALOME::MPISenderInt_ptr _this() {
      return (::SALOME::MPISenderInt_ptr) _do_this(::SALOME::MPISenderInt::_PD_repoId);
    }
  };

  class SocketSender :
    public virtual SALOME::_impl_SocketSender,
    public virtual Sender
  {
  public:
    virtual ~SocketSender();

    inline ::SALOME::SocketSender_ptr _this() {
      return (::SALOME::SocketSender_ptr) _do_this(::SALOME::SocketSender::_PD_repoId);
    }
  };

  class SocketSenderDouble :
    public virtual SALOME::_impl_SocketSenderDouble,
    public virtual SenderDouble,
      public virtual SocketSender
  {
  public:
    virtual ~SocketSenderDouble();

    inline ::SALOME::SocketSenderDouble_ptr _this() {
      return (::SALOME::SocketSenderDouble_ptr) _do_this(::SALOME::SocketSenderDouble::_PD_repoId);
    }
  };

  class SocketSenderInt :
    public virtual SALOME::_impl_SocketSenderInt,
    public virtual SenderInt,
      public virtual SocketSender
  {
  public:
    virtual ~SocketSenderInt();

    inline ::SALOME::SocketSenderInt_ptr _this() {
      return (::SALOME::SocketSenderInt_ptr) _do_this(::SALOME::SocketSenderInt::_PD_repoId);
    }
  };

  class Matrix :
    public virtual SALOME::_impl_Matrix,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~Matrix();

    inline ::SALOME::Matrix_ptr _this() {
      return (::SALOME::Matrix_ptr) _do_this(::SALOME::Matrix::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_SALOME
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



inline void
SALOME::MultiCommClass::_marshalObjRef(::SALOME::MultiCommClass_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::ServantLifeCycle::_marshalObjRef(::SALOME::ServantLifeCycle_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::Sender::_marshalObjRef(::SALOME::Sender_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::SenderDouble::_marshalObjRef(::SALOME::SenderDouble_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::SenderInt::_marshalObjRef(::SALOME::SenderInt_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::CorbaDoubleNCSender::_marshalObjRef(::SALOME::CorbaDoubleNCSender_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::CorbaDoubleCSender::_marshalObjRef(::SALOME::CorbaDoubleCSender_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::CorbaLongNCSender::_marshalObjRef(::SALOME::CorbaLongNCSender_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::CorbaLongCSender::_marshalObjRef(::SALOME::CorbaLongCSender_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::MPISender::_marshalObjRef(::SALOME::MPISender_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::MPISenderDouble::_marshalObjRef(::SALOME::MPISenderDouble_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::MPISenderInt::_marshalObjRef(::SALOME::MPISenderInt_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::SocketSender::_marshalObjRef(::SALOME::SocketSender_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::SocketSenderDouble::_marshalObjRef(::SALOME::SocketSenderDouble_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::SocketSenderInt::_marshalObjRef(::SALOME::SocketSenderInt_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
SALOME::Matrix::_marshalObjRef(::SALOME::Matrix_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_SALOME__Comm
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_SALOME__Comm
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__Comm
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__Comm
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__Comm
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__Comm
#endif

#endif  // __SALOME__Comm_hh__