// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __SMESH__Gen_hh__
#define __SMESH__Gen_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_SMESH__Gen
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_SMESH__Gen
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_SMESH__Gen
#endif



#ifndef __SALOME__Exception_hh_EXTERNAL_GUARD__
#define __SALOME__Exception_hh_EXTERNAL_GUARD__
#include <SALOME_Exception.hh>
#endif
#ifndef __SALOME__GenericObj_hh_EXTERNAL_GUARD__
#define __SALOME__GenericObj_hh_EXTERNAL_GUARD__
#include <SALOME_GenericObj.hh>
#endif
#ifndef __SALOMEDS_hh_EXTERNAL_GUARD__
#define __SALOMEDS_hh_EXTERNAL_GUARD__
#include <SALOMEDS.hh>
#endif
#ifndef __SALOME__PyNode_hh_EXTERNAL_GUARD__
#define __SALOME__PyNode_hh_EXTERNAL_GUARD__
#include <SALOME_PyNode.hh>
#endif
#ifndef __SALOME__Component_hh_EXTERNAL_GUARD__
#define __SALOME__Component_hh_EXTERNAL_GUARD__
#include <SALOME_Component.hh>
#endif
#ifndef __SALOMEDS__Attributes_hh_EXTERNAL_GUARD__
#define __SALOMEDS__Attributes_hh_EXTERNAL_GUARD__
#include <SALOMEDS_Attributes.hh>
#endif
#ifndef __GEOM__Gen_hh_EXTERNAL_GUARD__
#define __GEOM__Gen_hh_EXTERNAL_GUARD__
#include <GEOM_Gen.hh>
#endif
#ifndef __SALOME__Comm_hh_EXTERNAL_GUARD__
#define __SALOME__Comm_hh_EXTERNAL_GUARD__
#include <SALOME_Comm.hh>
#endif
#ifndef __MED_hh_EXTERNAL_GUARD__
#define __MED_hh_EXTERNAL_GUARD__
#include <MED.hh>
#endif
#ifndef __SMESH__Mesh_hh_EXTERNAL_GUARD__
#define __SMESH__Mesh_hh_EXTERNAL_GUARD__
#include <SMESH_Mesh.hh>
#endif
#ifndef __SMESH__Hypothesis_hh_EXTERNAL_GUARD__
#define __SMESH__Hypothesis_hh_EXTERNAL_GUARD__
#include <SMESH_Hypothesis.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 SMESH

_CORBA_MODULE_BEG

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_object_array;

  class object_array_var;

  class object_array : public _CORBA_Unbounded_Sequence_ObjRef< GEOM::_objref_GEOM_Object, _CORBA_ObjRef_Element< GEOM::_objref_GEOM_Object, GEOM::GEOM_Object_Helper> , GEOM::GEOM_Object_Helper >  {
  public:
    typedef object_array_var _var_type;
    inline object_array() {}
    inline object_array(const object_array& _s)
      : _CORBA_Unbounded_Sequence_ObjRef< GEOM::_objref_GEOM_Object, _CORBA_ObjRef_Element< GEOM::_objref_GEOM_Object, GEOM::GEOM_Object_Helper> , GEOM::GEOM_Object_Helper > (_s) {}

    inline object_array(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_ObjRef< GEOM::_objref_GEOM_Object, _CORBA_ObjRef_Element< GEOM::_objref_GEOM_Object, GEOM::GEOM_Object_Helper> , GEOM::GEOM_Object_Helper > (_max) {}
    inline object_array(_CORBA_ULong _max, _CORBA_ULong _len, GEOM::GEOM_Object_ptr* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_ObjRef< GEOM::_objref_GEOM_Object, _CORBA_ObjRef_Element< GEOM::_objref_GEOM_Object, GEOM::GEOM_Object_Helper> , GEOM::GEOM_Object_Helper > (_max, _len, _val, _rel) {}

  

    inline object_array& operator = (const object_array& _s) {
      _CORBA_Unbounded_Sequence_ObjRef< GEOM::_objref_GEOM_Object, _CORBA_ObjRef_Element< GEOM::_objref_GEOM_Object, GEOM::GEOM_Object_Helper> , GEOM::GEOM_Object_Helper > ::operator=(_s);
      return *this;
    }
  };

  class object_array_out;

  class object_array_var {
  public:
    inline object_array_var() : _pd_seq(0) {}
    inline object_array_var(object_array* _s) : _pd_seq(_s) {}
    inline object_array_var(const object_array_var& _s) {
      if( _s._pd_seq )  _pd_seq = new object_array(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~object_array_var() { if( _pd_seq )  delete _pd_seq; }
      
    inline object_array_var& operator = (object_array* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline object_array_var& operator = (const object_array_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new object_array;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline _CORBA_ObjRef_Element< GEOM::_objref_GEOM_Object, GEOM::GEOM_Object_Helper>  operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }

  

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

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

    inline _CORBA_ObjRef_Element< GEOM::_objref_GEOM_Object, GEOM::GEOM_Object_Helper>  operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }

  

    object_array*& _data;

  private:
    object_array_out();
    object_array_out& operator=(const object_array_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_mesh_array;

  class mesh_array_var;

  class mesh_array : public _CORBA_Unbounded_Sequence_ObjRef< _objref_SMESH_Mesh, _CORBA_ObjRef_Element< _objref_SMESH_Mesh, SMESH_Mesh_Helper> , SMESH_Mesh_Helper >  {
  public:
    typedef mesh_array_var _var_type;
    inline mesh_array() {}
    inline mesh_array(const mesh_array& _s)
      : _CORBA_Unbounded_Sequence_ObjRef< _objref_SMESH_Mesh, _CORBA_ObjRef_Element< _objref_SMESH_Mesh, SMESH_Mesh_Helper> , SMESH_Mesh_Helper > (_s) {}

    inline mesh_array(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_ObjRef< _objref_SMESH_Mesh, _CORBA_ObjRef_Element< _objref_SMESH_Mesh, SMESH_Mesh_Helper> , SMESH_Mesh_Helper > (_max) {}
    inline mesh_array(_CORBA_ULong _max, _CORBA_ULong _len, SMESH_Mesh_ptr* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_ObjRef< _objref_SMESH_Mesh, _CORBA_ObjRef_Element< _objref_SMESH_Mesh, SMESH_Mesh_Helper> , SMESH_Mesh_Helper > (_max, _len, _val, _rel) {}

  

    inline mesh_array& operator = (const mesh_array& _s) {
      _CORBA_Unbounded_Sequence_ObjRef< _objref_SMESH_Mesh, _CORBA_ObjRef_Element< _objref_SMESH_Mesh, SMESH_Mesh_Helper> , SMESH_Mesh_Helper > ::operator=(_s);
      return *this;
    }
  };

  class mesh_array_out;

  class mesh_array_var {
  public:
    inline mesh_array_var() : _pd_seq(0) {}
    inline mesh_array_var(mesh_array* _s) : _pd_seq(_s) {}
    inline mesh_array_var(const mesh_array_var& _s) {
      if( _s._pd_seq )  _pd_seq = new mesh_array(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~mesh_array_var() { if( _pd_seq )  delete _pd_seq; }
      
    inline mesh_array_var& operator = (mesh_array* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline mesh_array_var& operator = (const mesh_array_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new mesh_array;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline _CORBA_ObjRef_Element< _objref_SMESH_Mesh, SMESH_Mesh_Helper>  operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }

  

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

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

    inline _CORBA_ObjRef_Element< _objref_SMESH_Mesh, SMESH_Mesh_Helper>  operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }

  

    mesh_array*& _data;

  private:
    mesh_array_out();
    mesh_array_out& operator=(const mesh_array_var&);
  };

#ifndef __SMESH_mFilterManager__
#define __SMESH_mFilterManager__

  class FilterManager;
  class _objref_FilterManager;
  class _impl_FilterManager;
  
  typedef _objref_FilterManager* FilterManager_ptr;
  typedef FilterManager_ptr FilterManagerRef;

  class FilterManager_Helper {
  public:
    typedef FilterManager_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_FilterManager, FilterManager_Helper> FilterManager_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_FilterManager,FilterManager_Helper > FilterManager_out;

#endif

#ifndef __SMESH_mSMESH__Pattern__
#define __SMESH_mSMESH__Pattern__

  class SMESH_Pattern;
  class _objref_SMESH_Pattern;
  class _impl_SMESH_Pattern;
  
  typedef _objref_SMESH_Pattern* SMESH_Pattern_ptr;
  typedef SMESH_Pattern_ptr SMESH_PatternRef;

  class SMESH_Pattern_Helper {
  public:
    typedef SMESH_Pattern_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_SMESH_Pattern, SMESH_Pattern_Helper> SMESH_Pattern_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SMESH_Pattern,SMESH_Pattern_Helper > SMESH_Pattern_out;

#endif

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_HypothesisRoot _init_in_decl_( = 1 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_AlgorithmsRoot _init_in_decl_( = 2 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_FirstMeshRoot _init_in_decl_( = 3 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_RefOnShape _init_in_decl_( = 1 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_RefOnAppliedHypothesis _init_in_decl_( = 2 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_RefOnAppliedAlgorithms _init_in_decl_( = 3 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_FirstSubMesh _init_in_decl_( = 4 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_SubMeshOnVertex _init_in_decl_( = 4 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_SubMeshOnEdge _init_in_decl_( = 5 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_SubMeshOnWire _init_in_decl_( = 6 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_SubMeshOnFace _init_in_decl_( = 7 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_SubMeshOnShell _init_in_decl_( = 8 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_SubMeshOnSolid _init_in_decl_( = 9 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_SubMeshOnCompound _init_in_decl_( = 10 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_LastSubMesh _init_in_decl_( = 10 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_FirstGroup _init_in_decl_( = 11 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_NodeGroups _init_in_decl_( = 11 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_EdgeGroups _init_in_decl_( = 12 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_FaceGroups _init_in_decl_( = 13 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_VolumeGroups _init_in_decl_( = 14 );

  _CORBA_MODULE_VARINT const ::CORBA::Long Tag_LastGroup _init_in_decl_( = 14 );

  struct AlgoStateError {
    typedef _CORBA_ConstrType_Variable_Var<AlgoStateError> _var_type;

    
    Hypothesis_Status state;

    ::CORBA::String_member algoName;

    ::CORBA::Long algoDim;

    ::CORBA::Boolean isGlobalAlgo;

  

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

  typedef AlgoStateError::_var_type AlgoStateError_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< AlgoStateError,AlgoStateError_var > AlgoStateError_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AlgoStateError;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_algo_error_array;

  class algo_error_array_var;

  class algo_error_array : public _CORBA_Unbounded_Sequence< AlgoStateError >  {
  public:
    typedef algo_error_array_var _var_type;
    inline algo_error_array() {}
    inline algo_error_array(const algo_error_array& _s)
      : _CORBA_Unbounded_Sequence< AlgoStateError > (_s) {}

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

  

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

  class algo_error_array_out;

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

  

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

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

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

  

    algo_error_array*& _data;

  private:
    algo_error_array_out();
    algo_error_array_out& operator=(const algo_error_array_var&);
  };

  enum ComputeErrorName { COMPERR_OK, COMPERR_BAD_INPUT_MESH, COMPERR_STD_EXCEPTION, COMPERR_OCC_EXCEPTION, COMPERR_SLM_EXCEPTION, COMPERR_EXCEPTION, COMPERR_MEMORY_PB, COMPERR_ALGO_FAILED, COMPERR_BAD_SHAPE /*, __max_ComputeErrorName=0xffffffff */ };
  typedef ComputeErrorName& ComputeErrorName_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ComputeErrorName;

  struct ComputeError {
    typedef _CORBA_ConstrType_Variable_Var<ComputeError> _var_type;

    
    ::CORBA::Short code;

    ::CORBA::String_member comment;

    ::CORBA::String_member algoName;

    ::CORBA::Short subShapeID;

    ::CORBA::Boolean hasBadMesh;

  

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

  typedef ComputeError::_var_type ComputeError_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< ComputeError,ComputeError_var > ComputeError_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ComputeError;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_compute_error_array;

  class compute_error_array_var;

  class compute_error_array : public _CORBA_Unbounded_Sequence< ComputeError >  {
  public:
    typedef compute_error_array_var _var_type;
    inline compute_error_array() {}
    inline compute_error_array(const compute_error_array& _s)
      : _CORBA_Unbounded_Sequence< ComputeError > (_s) {}

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

  

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

  class compute_error_array_out;

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

  

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

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

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

  

    compute_error_array*& _data;

  private:
    compute_error_array_out();
    compute_error_array_out& operator=(const compute_error_array_var&);
  };

#ifndef __SMESH_mSMESH__Gen__
#define __SMESH_mSMESH__Gen__

  class SMESH_Gen;
  class _objref_SMESH_Gen;
  class _impl_SMESH_Gen;
  
  typedef _objref_SMESH_Gen* SMESH_Gen_ptr;
  typedef SMESH_Gen_ptr SMESH_GenRef;

  class SMESH_Gen_Helper {
  public:
    typedef SMESH_Gen_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_SMESH_Gen, SMESH_Gen_Helper> SMESH_Gen_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_SMESH_Gen,SMESH_Gen_Helper > SMESH_Gen_out;

#endif

  // interface SMESH_Gen
  class SMESH_Gen {
  public:
    // Declarations for this interface type.
    typedef SMESH_Gen_ptr _ptr_type;
    typedef SMESH_Gen_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_SMESH_Gen :
    public virtual Engines::_objref_Component,
    public virtual SALOMEDS::_objref_Driver
  {
  public:
    void SetGeomEngine(::GEOM::GEOM_Gen_ptr geomcompo);
    FilterManager_ptr CreateFilterManager();
    SMESH_Pattern_ptr GetPattern();
    void SetEmbeddedMode(::CORBA::Boolean theMode);
    ::CORBA::Boolean IsEmbeddedMode();
    void SetCurrentStudy(::SALOMEDS::Study_ptr theStudy);
    SALOMEDS::Study_ptr GetCurrentStudy();
    SMESH_Hypothesis_ptr CreateHypothesis(const char* theHypName, const char* theLibName);
    SMESH_Hypothesis_ptr GetHypothesisParameterValues(const char* theHypName, const char* theLibName, ::SMESH::SMESH_Mesh_ptr theMesh, ::GEOM::GEOM_Object_ptr theGeom, ::CORBA::Boolean byMesh);
    void SetBoundaryBoxSegmentation(::CORBA::Long theNbSegments);
    void SetDefaultNbSegments(::CORBA::Long theNbSegments);
    void SetName(const char* theObjectIOR, const char* theObjectName);
    SMESH_Mesh_ptr CreateMesh(::GEOM::GEOM_Object_ptr theObject);
    SMESH_Mesh_ptr CreateEmptyMesh();
    SMESH_Mesh_ptr CreateMeshesFromUNV(const char* theFileName);
    mesh_array* CreateMeshesFromMED(const char* theFileName, ::SMESH::DriverMED_ReadStatus& theStatus);
    SMESH_Mesh_ptr CreateMeshesFromSTL(const char* theFileName);
    ::CORBA::Boolean Compute(::SMESH::SMESH_Mesh_ptr theMesh, ::GEOM::GEOM_Object_ptr theSubObject);
    ::CORBA::Boolean IsReadyToCompute(::SMESH::SMESH_Mesh_ptr theMesh, ::GEOM::GEOM_Object_ptr theSubObject);
    long_array* Evaluate(::SMESH::SMESH_Mesh_ptr theMesh, ::GEOM::GEOM_Object_ptr theSubObject);
    MeshPreviewStruct* Precompute(::SMESH::SMESH_Mesh_ptr theMesh, ::GEOM::GEOM_Object_ptr theSubObject, ::SMESH::Dimension theDimension, ::SMESH::long_array& theShapesId);
    algo_error_array* GetAlgoState(::SMESH::SMESH_Mesh_ptr theMesh, ::GEOM::GEOM_Object_ptr theSubObject);
    compute_error_array* GetComputeErrors(::SMESH::SMESH_Mesh_ptr theMesh, ::GEOM::GEOM_Object_ptr theSubObject);
    MeshPreviewStruct* GetBadInputElements(::SMESH::SMESH_Mesh_ptr theMesh, ::CORBA::Short theSubShapeID);
    long_array* GetSubShapesId(::GEOM::GEOM_Object_ptr theMainObject, const ::SMESH::object_array& theListOfSubObjects);
    GEOM::GEOM_Object_ptr GetGeometryByMeshElement(::SMESH::SMESH_Mesh_ptr theMesh, ::CORBA::Long theElementID, const char* theGeomName);
    GEOM::GEOM_Object_ptr FindGeometryByMeshElement(::SMESH::SMESH_Mesh_ptr theMesh, ::CORBA::Long theElementID);
    SMESH_Mesh_ptr Concatenate(const ::SMESH::mesh_array& theMeshesArray, ::CORBA::Boolean theUniteIdenticalGroups, ::CORBA::Boolean theMergeNodesAndElements, ::CORBA::Double theMergeTolerance);
    SMESH_Mesh_ptr ConcatenateWithGroups(const ::SMESH::mesh_array& theMeshesArray, ::CORBA::Boolean theUniteIdenticalGroups, ::CORBA::Boolean theMergeNodesAndElements, ::CORBA::Double theMergeTolerance);
    ::CORBA::Long GetObjectId(::CORBA::Object_ptr theObject);
    ::CORBA::Boolean GetMEDVersion(const char* theFileName, ::SMESH::MED_VERSION& theVersion);
    string_array* GetMeshNames(const char* theFileName);

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

  protected:
    virtual ~_objref_SMESH_Gen();

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

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

    friend class SMESH_Gen;
  };

  class _pof_SMESH_Gen : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_SMESH_Gen() : _OMNI_NS(proxyObjectFactory)(SMESH_Gen::_PD_repoId) {}
    virtual ~_pof_SMESH_Gen();

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

  class _impl_SMESH_Gen :
    public virtual Engines::_impl_Component,
    public virtual SALOMEDS::_impl_Driver
  {
  public:
    virtual ~_impl_SMESH_Gen();

    virtual void SetGeomEngine(::GEOM::GEOM_Gen_ptr geomcompo) = 0;
    virtual FilterManager_ptr CreateFilterManager() = 0;
    virtual SMESH_Pattern_ptr GetPattern() = 0;
    virtual void SetEmbeddedMode(::CORBA::Boolean theMode) = 0;
    virtual ::CORBA::Boolean IsEmbeddedMode() = 0;
    virtual void SetCurrentStudy(::SALOMEDS::Study_ptr theStudy) = 0;
    virtual SALOMEDS::Study_ptr GetCurrentStudy() = 0;
    virtual SMESH_Hypothesis_ptr CreateHypothesis(const char* theHypName, const char* theLibName) = 0;
    virtual SMESH_Hypothesis_ptr GetHypothesisParameterValues(const char* theHypName, const char* theLibName, ::SMESH::SMESH_Mesh_ptr theMesh, ::GEOM::GEOM_Object_ptr theGeom, ::CORBA::Boolean byMesh) = 0;
    virtual void SetBoundaryBoxSegmentation(::CORBA::Long theNbSegments) = 0;
    virtual void SetDefaultNbSegments(::CORBA::Long theNbSegments) = 0;
    virtual void SetName(const char* theObjectIOR, const char* theObjectName) = 0;
    virtual SMESH_Mesh_ptr CreateMesh(::GEOM::GEOM_Object_ptr theObject) = 0;
    virtual SMESH_Mesh_ptr CreateEmptyMesh() = 0;
    virtual SMESH_Mesh_ptr CreateMeshesFromUNV(const char* theFileName) = 0;
    virtual mesh_array* CreateMeshesFromMED(const char* theFileName, ::SMESH::DriverMED_ReadStatus& theStatus) = 0;
    virtual SMESH_Mesh_ptr CreateMeshesFromSTL(const char* theFileName) = 0;
    virtual ::CORBA::Boolean Compute(::SMESH::SMESH_Mesh_ptr theMesh, ::GEOM::GEOM_Object_ptr theSubObject) = 0;
    virtual ::CORBA::Boolean IsReadyToCompute(::SMESH::SMESH_Mesh_ptr theMesh, ::GEOM::GEOM_Object_ptr theSubObject) = 0;
    virtual long_array* Evaluate(::SMESH::SMESH_Mesh_ptr theMesh, ::GEOM::GEOM_Object_ptr theSubObject) = 0;
    virtual MeshPreviewStruct* Precompute(::SMESH::SMESH_Mesh_ptr theMesh, ::GEOM::GEOM_Object_ptr theSubObject, ::SMESH::Dimension theDimension, ::SMESH::long_array& theShapesId) = 0;
    virtual algo_error_array* GetAlgoState(::SMESH::SMESH_Mesh_ptr theMesh, ::GEOM::GEOM_Object_ptr theSubObject) = 0;
    virtual compute_error_array* GetComputeErrors(::SMESH::SMESH_Mesh_ptr theMesh, ::GEOM::GEOM_Object_ptr theSubObject) = 0;
    virtual MeshPreviewStruct* GetBadInputElements(::SMESH::SMESH_Mesh_ptr theMesh, ::CORBA::Short theSubShapeID) = 0;
    virtual long_array* GetSubShapesId(::GEOM::GEOM_Object_ptr theMainObject, const ::SMESH::object_array& theListOfSubObjects) = 0;
    virtual GEOM::GEOM_Object_ptr GetGeometryByMeshElement(::SMESH::SMESH_Mesh_ptr theMesh, ::CORBA::Long theElementID, const char* theGeomName) = 0;
    virtual GEOM::GEOM_Object_ptr FindGeometryByMeshElement(::SMESH::SMESH_Mesh_ptr theMesh, ::CORBA::Long theElementID) = 0;
    virtual SMESH_Mesh_ptr Concatenate(const ::SMESH::mesh_array& theMeshesArray, ::CORBA::Boolean theUniteIdenticalGroups, ::CORBA::Boolean theMergeNodesAndElements, ::CORBA::Double theMergeTolerance) = 0;
    virtual SMESH_Mesh_ptr ConcatenateWithGroups(const ::SMESH::mesh_array& theMeshesArray, ::CORBA::Boolean theUniteIdenticalGroups, ::CORBA::Boolean theMergeNodesAndElements, ::CORBA::Double theMergeTolerance) = 0;
    virtual ::CORBA::Long GetObjectId(::CORBA::Object_ptr theObject) = 0;
    virtual ::CORBA::Boolean GetMEDVersion(const char* theFileName, ::SMESH::MED_VERSION& theVersion) = 0;
    virtual string_array* GetMeshNames(const char* theFileName) = 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_SMESH_Gen;

_CORBA_MODULE_END



_CORBA_MODULE POA_SMESH
_CORBA_MODULE_BEG

  class SMESH_Gen :
    public virtual SMESH::_impl_SMESH_Gen,
    public virtual POA_Engines::Component,
      public virtual POA_SALOMEDS::Driver
  {
  public:
    virtual ~SMESH_Gen();

    inline ::SMESH::SMESH_Gen_ptr _this() {
      return (::SMESH::SMESH_Gen_ptr) _do_this(::SMESH::SMESH_Gen::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_SMESH
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

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

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

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

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

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

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

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

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

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

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



inline void
SMESH::SMESH_Gen::_marshalObjRef(::SMESH::SMESH_Gen_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_SMESH__Gen
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_SMESH__Gen
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_SMESH__Gen
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_SMESH__Gen
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_SMESH__Gen
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_SMESH__Gen
#endif

#endif  // __SMESH__Gen_hh__

