// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __SMESH__BasicHypothesis_hh__
#define __SMESH__BasicHypothesis_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__BasicHypothesis
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_SMESH__BasicHypothesis
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_SMESH__BasicHypothesis
#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 __SMESH__Hypothesis_hh_EXTERNAL_GUARD__
#define __SMESH__Hypothesis_hh_EXTERNAL_GUARD__
#include <SMESH_Hypothesis.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



#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 StdMeshers

_CORBA_MODULE_BEG

#ifndef __StdMeshers_mStdMeshers__LocalLength__
#define __StdMeshers_mStdMeshers__LocalLength__

  class StdMeshers_LocalLength;
  class _objref_StdMeshers_LocalLength;
  class _impl_StdMeshers_LocalLength;
  
  typedef _objref_StdMeshers_LocalLength* StdMeshers_LocalLength_ptr;
  typedef StdMeshers_LocalLength_ptr StdMeshers_LocalLengthRef;

  class StdMeshers_LocalLength_Helper {
  public:
    typedef StdMeshers_LocalLength_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_StdMeshers_LocalLength, StdMeshers_LocalLength_Helper> StdMeshers_LocalLength_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_LocalLength,StdMeshers_LocalLength_Helper > StdMeshers_LocalLength_out;

#endif

  // interface StdMeshers_LocalLength
  class StdMeshers_LocalLength {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_LocalLength_ptr _ptr_type;
    typedef StdMeshers_LocalLength_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_StdMeshers_LocalLength :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetLength(::CORBA::Double length);
    void SetPrecision(::CORBA::Double precision);
    ::CORBA::Double GetLength();
    ::CORBA::Double GetPrecision();

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

  protected:
    virtual ~_objref_StdMeshers_LocalLength();

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

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

    friend class StdMeshers_LocalLength;
  };

  class _pof_StdMeshers_LocalLength : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_LocalLength() : _OMNI_NS(proxyObjectFactory)(StdMeshers_LocalLength::_PD_repoId) {}
    virtual ~_pof_StdMeshers_LocalLength();

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

  class _impl_StdMeshers_LocalLength :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_LocalLength();

    virtual void SetLength(::CORBA::Double length) = 0;
    virtual void SetPrecision(::CORBA::Double precision) = 0;
    virtual ::CORBA::Double GetLength() = 0;
    virtual ::CORBA::Double GetPrecision() = 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_StdMeshers_LocalLength;

#ifndef __StdMeshers_mStdMeshers__MaxLength__
#define __StdMeshers_mStdMeshers__MaxLength__

  class StdMeshers_MaxLength;
  class _objref_StdMeshers_MaxLength;
  class _impl_StdMeshers_MaxLength;
  
  typedef _objref_StdMeshers_MaxLength* StdMeshers_MaxLength_ptr;
  typedef StdMeshers_MaxLength_ptr StdMeshers_MaxLengthRef;

  class StdMeshers_MaxLength_Helper {
  public:
    typedef StdMeshers_MaxLength_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_StdMeshers_MaxLength, StdMeshers_MaxLength_Helper> StdMeshers_MaxLength_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_MaxLength,StdMeshers_MaxLength_Helper > StdMeshers_MaxLength_out;

#endif

  // interface StdMeshers_MaxLength
  class StdMeshers_MaxLength {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_MaxLength_ptr _ptr_type;
    typedef StdMeshers_MaxLength_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_StdMeshers_MaxLength :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetLength(::CORBA::Double length);
    ::CORBA::Double GetLength();
    ::CORBA::Boolean HavePreestimatedLength();
    ::CORBA::Double GetPreestimatedLength();
    void SetPreestimatedLength(::CORBA::Double length);
    void SetUsePreestimatedLength(::CORBA::Boolean toUse);
    ::CORBA::Boolean GetUsePreestimatedLength();

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

  protected:
    virtual ~_objref_StdMeshers_MaxLength();

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

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

    friend class StdMeshers_MaxLength;
  };

  class _pof_StdMeshers_MaxLength : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_MaxLength() : _OMNI_NS(proxyObjectFactory)(StdMeshers_MaxLength::_PD_repoId) {}
    virtual ~_pof_StdMeshers_MaxLength();

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

  class _impl_StdMeshers_MaxLength :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_MaxLength();

    virtual void SetLength(::CORBA::Double length) = 0;
    virtual ::CORBA::Double GetLength() = 0;
    virtual ::CORBA::Boolean HavePreestimatedLength() = 0;
    virtual ::CORBA::Double GetPreestimatedLength() = 0;
    virtual void SetPreestimatedLength(::CORBA::Double length) = 0;
    virtual void SetUsePreestimatedLength(::CORBA::Boolean toUse) = 0;
    virtual ::CORBA::Boolean GetUsePreestimatedLength() = 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_StdMeshers_MaxLength;

#ifndef __StdMeshers_mStdMeshers__AutomaticLength__
#define __StdMeshers_mStdMeshers__AutomaticLength__

  class StdMeshers_AutomaticLength;
  class _objref_StdMeshers_AutomaticLength;
  class _impl_StdMeshers_AutomaticLength;
  
  typedef _objref_StdMeshers_AutomaticLength* StdMeshers_AutomaticLength_ptr;
  typedef StdMeshers_AutomaticLength_ptr StdMeshers_AutomaticLengthRef;

  class StdMeshers_AutomaticLength_Helper {
  public:
    typedef StdMeshers_AutomaticLength_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_StdMeshers_AutomaticLength, StdMeshers_AutomaticLength_Helper> StdMeshers_AutomaticLength_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_AutomaticLength,StdMeshers_AutomaticLength_Helper > StdMeshers_AutomaticLength_out;

#endif

  // interface StdMeshers_AutomaticLength
  class StdMeshers_AutomaticLength {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_AutomaticLength_ptr _ptr_type;
    typedef StdMeshers_AutomaticLength_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_StdMeshers_AutomaticLength :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetFineness(::CORBA::Double theFineness);
    ::CORBA::Double GetFineness();

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

  protected:
    virtual ~_objref_StdMeshers_AutomaticLength();

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

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

    friend class StdMeshers_AutomaticLength;
  };

  class _pof_StdMeshers_AutomaticLength : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_AutomaticLength() : _OMNI_NS(proxyObjectFactory)(StdMeshers_AutomaticLength::_PD_repoId) {}
    virtual ~_pof_StdMeshers_AutomaticLength();

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

  class _impl_StdMeshers_AutomaticLength :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_AutomaticLength();

    virtual void SetFineness(::CORBA::Double theFineness) = 0;
    virtual ::CORBA::Double GetFineness() = 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_StdMeshers_AutomaticLength;

#ifndef __StdMeshers_mStdMeshers__NumberOfSegments__
#define __StdMeshers_mStdMeshers__NumberOfSegments__

  class StdMeshers_NumberOfSegments;
  class _objref_StdMeshers_NumberOfSegments;
  class _impl_StdMeshers_NumberOfSegments;
  
  typedef _objref_StdMeshers_NumberOfSegments* StdMeshers_NumberOfSegments_ptr;
  typedef StdMeshers_NumberOfSegments_ptr StdMeshers_NumberOfSegmentsRef;

  class StdMeshers_NumberOfSegments_Helper {
  public:
    typedef StdMeshers_NumberOfSegments_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_StdMeshers_NumberOfSegments, StdMeshers_NumberOfSegments_Helper> StdMeshers_NumberOfSegments_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_NumberOfSegments,StdMeshers_NumberOfSegments_Helper > StdMeshers_NumberOfSegments_out;

#endif

  // interface StdMeshers_NumberOfSegments
  class StdMeshers_NumberOfSegments {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_NumberOfSegments_ptr _ptr_type;
    typedef StdMeshers_NumberOfSegments_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_StdMeshers_NumberOfSegments :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    SMESH::double_array* BuildDistributionExpr(const char* func, ::CORBA::Long nbSeg, ::CORBA::Long conv);
    SMESH::double_array* BuildDistributionTab(const ::SMESH::double_array& func, ::CORBA::Long nbSeg, ::CORBA::Long conv);
    void SetNumberOfSegments(::CORBA::Long segmentsNumber);
    ::CORBA::Long GetNumberOfSegments();
    void SetDistrType(::CORBA::Long typ);
    ::CORBA::Long GetDistrType();
    void SetScaleFactor(::CORBA::Double scaleFactor);
    ::CORBA::Double GetScaleFactor();
    void SetTableFunction(const ::SMESH::double_array& table);
    SMESH::double_array* GetTableFunction();
    void SetExpressionFunction(const char* expr);
    char* GetExpressionFunction();
    void SetConversionMode(::CORBA::Long conv);
    ::CORBA::Long ConversionMode();
    void SetReversedEdges(const ::SMESH::long_array& list);
    SMESH::long_array* GetReversedEdges();
    void SetObjectEntry(const char* entry);
    char* GetObjectEntry();

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

  protected:
    virtual ~_objref_StdMeshers_NumberOfSegments();

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

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

    friend class StdMeshers_NumberOfSegments;
  };

  class _pof_StdMeshers_NumberOfSegments : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_NumberOfSegments() : _OMNI_NS(proxyObjectFactory)(StdMeshers_NumberOfSegments::_PD_repoId) {}
    virtual ~_pof_StdMeshers_NumberOfSegments();

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

  class _impl_StdMeshers_NumberOfSegments :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_NumberOfSegments();

    virtual SMESH::double_array* BuildDistributionExpr(const char* func, ::CORBA::Long nbSeg, ::CORBA::Long conv) = 0;
    virtual SMESH::double_array* BuildDistributionTab(const ::SMESH::double_array& func, ::CORBA::Long nbSeg, ::CORBA::Long conv) = 0;
    virtual void SetNumberOfSegments(::CORBA::Long segmentsNumber) = 0;
    virtual ::CORBA::Long GetNumberOfSegments() = 0;
    virtual void SetDistrType(::CORBA::Long typ) = 0;
    virtual ::CORBA::Long GetDistrType() = 0;
    virtual void SetScaleFactor(::CORBA::Double scaleFactor) = 0;
    virtual ::CORBA::Double GetScaleFactor() = 0;
    virtual void SetTableFunction(const ::SMESH::double_array& table) = 0;
    virtual SMESH::double_array* GetTableFunction() = 0;
    virtual void SetExpressionFunction(const char* expr) = 0;
    virtual char* GetExpressionFunction() = 0;
    virtual void SetConversionMode(::CORBA::Long conv) = 0;
    virtual ::CORBA::Long ConversionMode() = 0;
    virtual void SetReversedEdges(const ::SMESH::long_array& list) = 0;
    virtual SMESH::long_array* GetReversedEdges() = 0;
    virtual void SetObjectEntry(const char* entry) = 0;
    virtual char* GetObjectEntry() = 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_StdMeshers_NumberOfSegments;

#ifndef __StdMeshers_mStdMeshers__Arithmetic1D__
#define __StdMeshers_mStdMeshers__Arithmetic1D__

  class StdMeshers_Arithmetic1D;
  class _objref_StdMeshers_Arithmetic1D;
  class _impl_StdMeshers_Arithmetic1D;
  
  typedef _objref_StdMeshers_Arithmetic1D* StdMeshers_Arithmetic1D_ptr;
  typedef StdMeshers_Arithmetic1D_ptr StdMeshers_Arithmetic1DRef;

  class StdMeshers_Arithmetic1D_Helper {
  public:
    typedef StdMeshers_Arithmetic1D_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_StdMeshers_Arithmetic1D, StdMeshers_Arithmetic1D_Helper> StdMeshers_Arithmetic1D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_Arithmetic1D,StdMeshers_Arithmetic1D_Helper > StdMeshers_Arithmetic1D_out;

#endif

  // interface StdMeshers_Arithmetic1D
  class StdMeshers_Arithmetic1D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_Arithmetic1D_ptr _ptr_type;
    typedef StdMeshers_Arithmetic1D_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_StdMeshers_Arithmetic1D :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetLength(::CORBA::Double length, ::CORBA::Boolean isStartLength);
    void SetStartLength(::CORBA::Double length);
    void SetEndLength(::CORBA::Double length);
    ::CORBA::Double GetLength(::CORBA::Boolean isStartLength);
    void SetReversedEdges(const ::SMESH::long_array& list);
    SMESH::long_array* GetReversedEdges();
    void SetObjectEntry(const char* entry);
    char* GetObjectEntry();

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

  protected:
    virtual ~_objref_StdMeshers_Arithmetic1D();

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

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

    friend class StdMeshers_Arithmetic1D;
  };

  class _pof_StdMeshers_Arithmetic1D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_Arithmetic1D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_Arithmetic1D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_Arithmetic1D();

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

  class _impl_StdMeshers_Arithmetic1D :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_Arithmetic1D();

    virtual void SetLength(::CORBA::Double length, ::CORBA::Boolean isStartLength) = 0;
    virtual void SetStartLength(::CORBA::Double length) = 0;
    virtual void SetEndLength(::CORBA::Double length) = 0;
    virtual ::CORBA::Double GetLength(::CORBA::Boolean isStartLength) = 0;
    virtual void SetReversedEdges(const ::SMESH::long_array& list) = 0;
    virtual SMESH::long_array* GetReversedEdges() = 0;
    virtual void SetObjectEntry(const char* entry) = 0;
    virtual char* GetObjectEntry() = 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_StdMeshers_Arithmetic1D;

#ifndef __StdMeshers_mStdMeshers__MaxElementArea__
#define __StdMeshers_mStdMeshers__MaxElementArea__

  class StdMeshers_MaxElementArea;
  class _objref_StdMeshers_MaxElementArea;
  class _impl_StdMeshers_MaxElementArea;
  
  typedef _objref_StdMeshers_MaxElementArea* StdMeshers_MaxElementArea_ptr;
  typedef StdMeshers_MaxElementArea_ptr StdMeshers_MaxElementAreaRef;

  class StdMeshers_MaxElementArea_Helper {
  public:
    typedef StdMeshers_MaxElementArea_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_StdMeshers_MaxElementArea, StdMeshers_MaxElementArea_Helper> StdMeshers_MaxElementArea_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_MaxElementArea,StdMeshers_MaxElementArea_Helper > StdMeshers_MaxElementArea_out;

#endif

  // interface StdMeshers_MaxElementArea
  class StdMeshers_MaxElementArea {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_MaxElementArea_ptr _ptr_type;
    typedef StdMeshers_MaxElementArea_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_StdMeshers_MaxElementArea :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetMaxElementArea(::CORBA::Double area);
    ::CORBA::Double GetMaxElementArea();

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

  protected:
    virtual ~_objref_StdMeshers_MaxElementArea();

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

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

    friend class StdMeshers_MaxElementArea;
  };

  class _pof_StdMeshers_MaxElementArea : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_MaxElementArea() : _OMNI_NS(proxyObjectFactory)(StdMeshers_MaxElementArea::_PD_repoId) {}
    virtual ~_pof_StdMeshers_MaxElementArea();

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

  class _impl_StdMeshers_MaxElementArea :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_MaxElementArea();

    virtual void SetMaxElementArea(::CORBA::Double area) = 0;
    virtual ::CORBA::Double GetMaxElementArea() = 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_StdMeshers_MaxElementArea;

#ifndef __StdMeshers_mStdMeshers__LengthFromEdges__
#define __StdMeshers_mStdMeshers__LengthFromEdges__

  class StdMeshers_LengthFromEdges;
  class _objref_StdMeshers_LengthFromEdges;
  class _impl_StdMeshers_LengthFromEdges;
  
  typedef _objref_StdMeshers_LengthFromEdges* StdMeshers_LengthFromEdges_ptr;
  typedef StdMeshers_LengthFromEdges_ptr StdMeshers_LengthFromEdgesRef;

  class StdMeshers_LengthFromEdges_Helper {
  public:
    typedef StdMeshers_LengthFromEdges_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_StdMeshers_LengthFromEdges, StdMeshers_LengthFromEdges_Helper> StdMeshers_LengthFromEdges_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_LengthFromEdges,StdMeshers_LengthFromEdges_Helper > StdMeshers_LengthFromEdges_out;

#endif

  // interface StdMeshers_LengthFromEdges
  class StdMeshers_LengthFromEdges {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_LengthFromEdges_ptr _ptr_type;
    typedef StdMeshers_LengthFromEdges_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_StdMeshers_LengthFromEdges :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetMode(::CORBA::Long mode);
    ::CORBA::Long GetMode();

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

  protected:
    virtual ~_objref_StdMeshers_LengthFromEdges();

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

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

    friend class StdMeshers_LengthFromEdges;
  };

  class _pof_StdMeshers_LengthFromEdges : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_LengthFromEdges() : _OMNI_NS(proxyObjectFactory)(StdMeshers_LengthFromEdges::_PD_repoId) {}
    virtual ~_pof_StdMeshers_LengthFromEdges();

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

  class _impl_StdMeshers_LengthFromEdges :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_LengthFromEdges();

    virtual void SetMode(::CORBA::Long mode) = 0;
    virtual ::CORBA::Long GetMode() = 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_StdMeshers_LengthFromEdges;

#ifndef __StdMeshers_mStdMeshers__StartEndLength__
#define __StdMeshers_mStdMeshers__StartEndLength__

  class StdMeshers_StartEndLength;
  class _objref_StdMeshers_StartEndLength;
  class _impl_StdMeshers_StartEndLength;
  
  typedef _objref_StdMeshers_StartEndLength* StdMeshers_StartEndLength_ptr;
  typedef StdMeshers_StartEndLength_ptr StdMeshers_StartEndLengthRef;

  class StdMeshers_StartEndLength_Helper {
  public:
    typedef StdMeshers_StartEndLength_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_StdMeshers_StartEndLength, StdMeshers_StartEndLength_Helper> StdMeshers_StartEndLength_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_StartEndLength,StdMeshers_StartEndLength_Helper > StdMeshers_StartEndLength_out;

#endif

  // interface StdMeshers_StartEndLength
  class StdMeshers_StartEndLength {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_StartEndLength_ptr _ptr_type;
    typedef StdMeshers_StartEndLength_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_StdMeshers_StartEndLength :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetLength(::CORBA::Double length, ::CORBA::Boolean isStartLength);
    void SetStartLength(::CORBA::Double length);
    void SetEndLength(::CORBA::Double length);
    ::CORBA::Double GetLength(::CORBA::Boolean isStartLength);
    void SetReversedEdges(const ::SMESH::long_array& list);
    SMESH::long_array* GetReversedEdges();
    void SetObjectEntry(const char* entry);
    char* GetObjectEntry();

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

  protected:
    virtual ~_objref_StdMeshers_StartEndLength();

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

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

    friend class StdMeshers_StartEndLength;
  };

  class _pof_StdMeshers_StartEndLength : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_StartEndLength() : _OMNI_NS(proxyObjectFactory)(StdMeshers_StartEndLength::_PD_repoId) {}
    virtual ~_pof_StdMeshers_StartEndLength();

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

  class _impl_StdMeshers_StartEndLength :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_StartEndLength();

    virtual void SetLength(::CORBA::Double length, ::CORBA::Boolean isStartLength) = 0;
    virtual void SetStartLength(::CORBA::Double length) = 0;
    virtual void SetEndLength(::CORBA::Double length) = 0;
    virtual ::CORBA::Double GetLength(::CORBA::Boolean isStartLength) = 0;
    virtual void SetReversedEdges(const ::SMESH::long_array& list) = 0;
    virtual SMESH::long_array* GetReversedEdges() = 0;
    virtual void SetObjectEntry(const char* entry) = 0;
    virtual char* GetObjectEntry() = 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_StdMeshers_StartEndLength;

#ifndef __StdMeshers_mStdMeshers__Deflection1D__
#define __StdMeshers_mStdMeshers__Deflection1D__

  class StdMeshers_Deflection1D;
  class _objref_StdMeshers_Deflection1D;
  class _impl_StdMeshers_Deflection1D;
  
  typedef _objref_StdMeshers_Deflection1D* StdMeshers_Deflection1D_ptr;
  typedef StdMeshers_Deflection1D_ptr StdMeshers_Deflection1DRef;

  class StdMeshers_Deflection1D_Helper {
  public:
    typedef StdMeshers_Deflection1D_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_StdMeshers_Deflection1D, StdMeshers_Deflection1D_Helper> StdMeshers_Deflection1D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_Deflection1D,StdMeshers_Deflection1D_Helper > StdMeshers_Deflection1D_out;

#endif

  // interface StdMeshers_Deflection1D
  class StdMeshers_Deflection1D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_Deflection1D_ptr _ptr_type;
    typedef StdMeshers_Deflection1D_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_StdMeshers_Deflection1D :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetDeflection(::CORBA::Double deflection);
    ::CORBA::Double GetDeflection();

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

  protected:
    virtual ~_objref_StdMeshers_Deflection1D();

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

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

    friend class StdMeshers_Deflection1D;
  };

  class _pof_StdMeshers_Deflection1D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_Deflection1D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_Deflection1D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_Deflection1D();

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

  class _impl_StdMeshers_Deflection1D :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_Deflection1D();

    virtual void SetDeflection(::CORBA::Double deflection) = 0;
    virtual ::CORBA::Double GetDeflection() = 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_StdMeshers_Deflection1D;

#ifndef __StdMeshers_mStdMeshers__FixedPoints1D__
#define __StdMeshers_mStdMeshers__FixedPoints1D__

  class StdMeshers_FixedPoints1D;
  class _objref_StdMeshers_FixedPoints1D;
  class _impl_StdMeshers_FixedPoints1D;
  
  typedef _objref_StdMeshers_FixedPoints1D* StdMeshers_FixedPoints1D_ptr;
  typedef StdMeshers_FixedPoints1D_ptr StdMeshers_FixedPoints1DRef;

  class StdMeshers_FixedPoints1D_Helper {
  public:
    typedef StdMeshers_FixedPoints1D_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_StdMeshers_FixedPoints1D, StdMeshers_FixedPoints1D_Helper> StdMeshers_FixedPoints1D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_FixedPoints1D,StdMeshers_FixedPoints1D_Helper > StdMeshers_FixedPoints1D_out;

#endif

  // interface StdMeshers_FixedPoints1D
  class StdMeshers_FixedPoints1D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_FixedPoints1D_ptr _ptr_type;
    typedef StdMeshers_FixedPoints1D_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_StdMeshers_FixedPoints1D :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetPoints(const ::SMESH::double_array& listParams);
    void SetNbSegments(const ::SMESH::long_array& listNbSeg);
    SMESH::double_array* GetPoints();
    SMESH::long_array* GetNbSegments();
    void SetReversedEdges(const ::SMESH::long_array& list);
    SMESH::long_array* GetReversedEdges();
    void SetObjectEntry(const char* entry);
    char* GetObjectEntry();

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

  protected:
    virtual ~_objref_StdMeshers_FixedPoints1D();

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

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

    friend class StdMeshers_FixedPoints1D;
  };

  class _pof_StdMeshers_FixedPoints1D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_FixedPoints1D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_FixedPoints1D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_FixedPoints1D();

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

  class _impl_StdMeshers_FixedPoints1D :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_FixedPoints1D();

    virtual void SetPoints(const ::SMESH::double_array& listParams) = 0;
    virtual void SetNbSegments(const ::SMESH::long_array& listNbSeg) = 0;
    virtual SMESH::double_array* GetPoints() = 0;
    virtual SMESH::long_array* GetNbSegments() = 0;
    virtual void SetReversedEdges(const ::SMESH::long_array& list) = 0;
    virtual SMESH::long_array* GetReversedEdges() = 0;
    virtual void SetObjectEntry(const char* entry) = 0;
    virtual char* GetObjectEntry() = 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_StdMeshers_FixedPoints1D;

#ifndef __StdMeshers_mStdMeshers__MaxElementVolume__
#define __StdMeshers_mStdMeshers__MaxElementVolume__

  class StdMeshers_MaxElementVolume;
  class _objref_StdMeshers_MaxElementVolume;
  class _impl_StdMeshers_MaxElementVolume;
  
  typedef _objref_StdMeshers_MaxElementVolume* StdMeshers_MaxElementVolume_ptr;
  typedef StdMeshers_MaxElementVolume_ptr StdMeshers_MaxElementVolumeRef;

  class StdMeshers_MaxElementVolume_Helper {
  public:
    typedef StdMeshers_MaxElementVolume_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_StdMeshers_MaxElementVolume, StdMeshers_MaxElementVolume_Helper> StdMeshers_MaxElementVolume_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_MaxElementVolume,StdMeshers_MaxElementVolume_Helper > StdMeshers_MaxElementVolume_out;

#endif

  // interface StdMeshers_MaxElementVolume
  class StdMeshers_MaxElementVolume {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_MaxElementVolume_ptr _ptr_type;
    typedef StdMeshers_MaxElementVolume_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_StdMeshers_MaxElementVolume :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetMaxElementVolume(::CORBA::Double volume);
    ::CORBA::Double GetMaxElementVolume();

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

  protected:
    virtual ~_objref_StdMeshers_MaxElementVolume();

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

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

    friend class StdMeshers_MaxElementVolume;
  };

  class _pof_StdMeshers_MaxElementVolume : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_MaxElementVolume() : _OMNI_NS(proxyObjectFactory)(StdMeshers_MaxElementVolume::_PD_repoId) {}
    virtual ~_pof_StdMeshers_MaxElementVolume();

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

  class _impl_StdMeshers_MaxElementVolume :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_MaxElementVolume();

    virtual void SetMaxElementVolume(::CORBA::Double volume) = 0;
    virtual ::CORBA::Double GetMaxElementVolume() = 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_StdMeshers_MaxElementVolume;

#ifndef __StdMeshers_mStdMeshers__NotConformAllowed__
#define __StdMeshers_mStdMeshers__NotConformAllowed__

  class StdMeshers_NotConformAllowed;
  class _objref_StdMeshers_NotConformAllowed;
  class _impl_StdMeshers_NotConformAllowed;
  
  typedef _objref_StdMeshers_NotConformAllowed* StdMeshers_NotConformAllowed_ptr;
  typedef StdMeshers_NotConformAllowed_ptr StdMeshers_NotConformAllowedRef;

  class StdMeshers_NotConformAllowed_Helper {
  public:
    typedef StdMeshers_NotConformAllowed_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_StdMeshers_NotConformAllowed, StdMeshers_NotConformAllowed_Helper> StdMeshers_NotConformAllowed_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_NotConformAllowed,StdMeshers_NotConformAllowed_Helper > StdMeshers_NotConformAllowed_out;

#endif

  // interface StdMeshers_NotConformAllowed
  class StdMeshers_NotConformAllowed {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_NotConformAllowed_ptr _ptr_type;
    typedef StdMeshers_NotConformAllowed_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_StdMeshers_NotConformAllowed :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_NotConformAllowed();

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

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

    friend class StdMeshers_NotConformAllowed;
  };

  class _pof_StdMeshers_NotConformAllowed : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_NotConformAllowed() : _OMNI_NS(proxyObjectFactory)(StdMeshers_NotConformAllowed::_PD_repoId) {}
    virtual ~_pof_StdMeshers_NotConformAllowed();

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

  class _impl_StdMeshers_NotConformAllowed :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_NotConformAllowed();

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

#ifndef __StdMeshers_mStdMeshers__Propagation__
#define __StdMeshers_mStdMeshers__Propagation__

  class StdMeshers_Propagation;
  class _objref_StdMeshers_Propagation;
  class _impl_StdMeshers_Propagation;
  
  typedef _objref_StdMeshers_Propagation* StdMeshers_Propagation_ptr;
  typedef StdMeshers_Propagation_ptr StdMeshers_PropagationRef;

  class StdMeshers_Propagation_Helper {
  public:
    typedef StdMeshers_Propagation_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_StdMeshers_Propagation, StdMeshers_Propagation_Helper> StdMeshers_Propagation_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_Propagation,StdMeshers_Propagation_Helper > StdMeshers_Propagation_out;

#endif

  // interface StdMeshers_Propagation
  class StdMeshers_Propagation {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_Propagation_ptr _ptr_type;
    typedef StdMeshers_Propagation_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_StdMeshers_Propagation :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_Propagation();

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

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

    friend class StdMeshers_Propagation;
  };

  class _pof_StdMeshers_Propagation : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_Propagation() : _OMNI_NS(proxyObjectFactory)(StdMeshers_Propagation::_PD_repoId) {}
    virtual ~_pof_StdMeshers_Propagation();

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

  class _impl_StdMeshers_Propagation :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_Propagation();

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

#ifndef __StdMeshers_mStdMeshers__QuadranglePreference__
#define __StdMeshers_mStdMeshers__QuadranglePreference__

  class StdMeshers_QuadranglePreference;
  class _objref_StdMeshers_QuadranglePreference;
  class _impl_StdMeshers_QuadranglePreference;
  
  typedef _objref_StdMeshers_QuadranglePreference* StdMeshers_QuadranglePreference_ptr;
  typedef StdMeshers_QuadranglePreference_ptr StdMeshers_QuadranglePreferenceRef;

  class StdMeshers_QuadranglePreference_Helper {
  public:
    typedef StdMeshers_QuadranglePreference_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_StdMeshers_QuadranglePreference, StdMeshers_QuadranglePreference_Helper> StdMeshers_QuadranglePreference_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_QuadranglePreference,StdMeshers_QuadranglePreference_Helper > StdMeshers_QuadranglePreference_out;

#endif

  // interface StdMeshers_QuadranglePreference
  class StdMeshers_QuadranglePreference {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_QuadranglePreference_ptr _ptr_type;
    typedef StdMeshers_QuadranglePreference_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_StdMeshers_QuadranglePreference :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_QuadranglePreference();

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

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

    friend class StdMeshers_QuadranglePreference;
  };

  class _pof_StdMeshers_QuadranglePreference : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_QuadranglePreference() : _OMNI_NS(proxyObjectFactory)(StdMeshers_QuadranglePreference::_PD_repoId) {}
    virtual ~_pof_StdMeshers_QuadranglePreference();

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

  class _impl_StdMeshers_QuadranglePreference :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_QuadranglePreference();

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

#ifndef __StdMeshers_mStdMeshers__TrianglePreference__
#define __StdMeshers_mStdMeshers__TrianglePreference__

  class StdMeshers_TrianglePreference;
  class _objref_StdMeshers_TrianglePreference;
  class _impl_StdMeshers_TrianglePreference;
  
  typedef _objref_StdMeshers_TrianglePreference* StdMeshers_TrianglePreference_ptr;
  typedef StdMeshers_TrianglePreference_ptr StdMeshers_TrianglePreferenceRef;

  class StdMeshers_TrianglePreference_Helper {
  public:
    typedef StdMeshers_TrianglePreference_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_StdMeshers_TrianglePreference, StdMeshers_TrianglePreference_Helper> StdMeshers_TrianglePreference_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_TrianglePreference,StdMeshers_TrianglePreference_Helper > StdMeshers_TrianglePreference_out;

#endif

  // interface StdMeshers_TrianglePreference
  class StdMeshers_TrianglePreference {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_TrianglePreference_ptr _ptr_type;
    typedef StdMeshers_TrianglePreference_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_StdMeshers_TrianglePreference :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_TrianglePreference();

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

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

    friend class StdMeshers_TrianglePreference;
  };

  class _pof_StdMeshers_TrianglePreference : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_TrianglePreference() : _OMNI_NS(proxyObjectFactory)(StdMeshers_TrianglePreference::_PD_repoId) {}
    virtual ~_pof_StdMeshers_TrianglePreference();

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

  class _impl_StdMeshers_TrianglePreference :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_TrianglePreference();

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

#ifndef __StdMeshers_mStdMeshers__QuadraticMesh__
#define __StdMeshers_mStdMeshers__QuadraticMesh__

  class StdMeshers_QuadraticMesh;
  class _objref_StdMeshers_QuadraticMesh;
  class _impl_StdMeshers_QuadraticMesh;
  
  typedef _objref_StdMeshers_QuadraticMesh* StdMeshers_QuadraticMesh_ptr;
  typedef StdMeshers_QuadraticMesh_ptr StdMeshers_QuadraticMeshRef;

  class StdMeshers_QuadraticMesh_Helper {
  public:
    typedef StdMeshers_QuadraticMesh_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_StdMeshers_QuadraticMesh, StdMeshers_QuadraticMesh_Helper> StdMeshers_QuadraticMesh_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_QuadraticMesh,StdMeshers_QuadraticMesh_Helper > StdMeshers_QuadraticMesh_out;

#endif

  // interface StdMeshers_QuadraticMesh
  class StdMeshers_QuadraticMesh {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_QuadraticMesh_ptr _ptr_type;
    typedef StdMeshers_QuadraticMesh_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_StdMeshers_QuadraticMesh :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_QuadraticMesh();

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

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

    friend class StdMeshers_QuadraticMesh;
  };

  class _pof_StdMeshers_QuadraticMesh : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_QuadraticMesh() : _OMNI_NS(proxyObjectFactory)(StdMeshers_QuadraticMesh::_PD_repoId) {}
    virtual ~_pof_StdMeshers_QuadraticMesh();

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

  class _impl_StdMeshers_QuadraticMesh :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_QuadraticMesh();

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

#ifndef __StdMeshers_mStdMeshers__NumberOfLayers__
#define __StdMeshers_mStdMeshers__NumberOfLayers__

  class StdMeshers_NumberOfLayers;
  class _objref_StdMeshers_NumberOfLayers;
  class _impl_StdMeshers_NumberOfLayers;
  
  typedef _objref_StdMeshers_NumberOfLayers* StdMeshers_NumberOfLayers_ptr;
  typedef StdMeshers_NumberOfLayers_ptr StdMeshers_NumberOfLayersRef;

  class StdMeshers_NumberOfLayers_Helper {
  public:
    typedef StdMeshers_NumberOfLayers_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_StdMeshers_NumberOfLayers, StdMeshers_NumberOfLayers_Helper> StdMeshers_NumberOfLayers_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_NumberOfLayers,StdMeshers_NumberOfLayers_Helper > StdMeshers_NumberOfLayers_out;

#endif

  // interface StdMeshers_NumberOfLayers
  class StdMeshers_NumberOfLayers {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_NumberOfLayers_ptr _ptr_type;
    typedef StdMeshers_NumberOfLayers_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_StdMeshers_NumberOfLayers :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetNumberOfLayers(::CORBA::Long numberOfLayers);
    ::CORBA::Long GetNumberOfLayers();

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

  protected:
    virtual ~_objref_StdMeshers_NumberOfLayers();

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

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

    friend class StdMeshers_NumberOfLayers;
  };

  class _pof_StdMeshers_NumberOfLayers : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_NumberOfLayers() : _OMNI_NS(proxyObjectFactory)(StdMeshers_NumberOfLayers::_PD_repoId) {}
    virtual ~_pof_StdMeshers_NumberOfLayers();

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

  class _impl_StdMeshers_NumberOfLayers :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_NumberOfLayers();

    virtual void SetNumberOfLayers(::CORBA::Long numberOfLayers) = 0;
    virtual ::CORBA::Long GetNumberOfLayers() = 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_StdMeshers_NumberOfLayers;

#ifndef __StdMeshers_mStdMeshers__LayerDistribution__
#define __StdMeshers_mStdMeshers__LayerDistribution__

  class StdMeshers_LayerDistribution;
  class _objref_StdMeshers_LayerDistribution;
  class _impl_StdMeshers_LayerDistribution;
  
  typedef _objref_StdMeshers_LayerDistribution* StdMeshers_LayerDistribution_ptr;
  typedef StdMeshers_LayerDistribution_ptr StdMeshers_LayerDistributionRef;

  class StdMeshers_LayerDistribution_Helper {
  public:
    typedef StdMeshers_LayerDistribution_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_StdMeshers_LayerDistribution, StdMeshers_LayerDistribution_Helper> StdMeshers_LayerDistribution_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_LayerDistribution,StdMeshers_LayerDistribution_Helper > StdMeshers_LayerDistribution_out;

#endif

  // interface StdMeshers_LayerDistribution
  class StdMeshers_LayerDistribution {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_LayerDistribution_ptr _ptr_type;
    typedef StdMeshers_LayerDistribution_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_StdMeshers_LayerDistribution :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetLayerDistribution(::SMESH::SMESH_Hypothesis_ptr distributionHyp);
    SMESH::SMESH_Hypothesis_ptr GetLayerDistribution();

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

  protected:
    virtual ~_objref_StdMeshers_LayerDistribution();

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

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

    friend class StdMeshers_LayerDistribution;
  };

  class _pof_StdMeshers_LayerDistribution : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_LayerDistribution() : _OMNI_NS(proxyObjectFactory)(StdMeshers_LayerDistribution::_PD_repoId) {}
    virtual ~_pof_StdMeshers_LayerDistribution();

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

  class _impl_StdMeshers_LayerDistribution :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_LayerDistribution();

    virtual void SetLayerDistribution(::SMESH::SMESH_Hypothesis_ptr distributionHyp) = 0;
    virtual SMESH::SMESH_Hypothesis_ptr GetLayerDistribution() = 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_StdMeshers_LayerDistribution;

#ifndef __StdMeshers_mStdMeshers__NumberOfLayers2D__
#define __StdMeshers_mStdMeshers__NumberOfLayers2D__

  class StdMeshers_NumberOfLayers2D;
  class _objref_StdMeshers_NumberOfLayers2D;
  class _impl_StdMeshers_NumberOfLayers2D;
  
  typedef _objref_StdMeshers_NumberOfLayers2D* StdMeshers_NumberOfLayers2D_ptr;
  typedef StdMeshers_NumberOfLayers2D_ptr StdMeshers_NumberOfLayers2DRef;

  class StdMeshers_NumberOfLayers2D_Helper {
  public:
    typedef StdMeshers_NumberOfLayers2D_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_StdMeshers_NumberOfLayers2D, StdMeshers_NumberOfLayers2D_Helper> StdMeshers_NumberOfLayers2D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_NumberOfLayers2D,StdMeshers_NumberOfLayers2D_Helper > StdMeshers_NumberOfLayers2D_out;

#endif

  // interface StdMeshers_NumberOfLayers2D
  class StdMeshers_NumberOfLayers2D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_NumberOfLayers2D_ptr _ptr_type;
    typedef StdMeshers_NumberOfLayers2D_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_StdMeshers_NumberOfLayers2D :
    public virtual _objref_StdMeshers_NumberOfLayers
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_NumberOfLayers2D();

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

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

    friend class StdMeshers_NumberOfLayers2D;
  };

  class _pof_StdMeshers_NumberOfLayers2D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_NumberOfLayers2D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_NumberOfLayers2D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_NumberOfLayers2D();

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

  class _impl_StdMeshers_NumberOfLayers2D :
    public virtual _impl_StdMeshers_NumberOfLayers
  {
  public:
    virtual ~_impl_StdMeshers_NumberOfLayers2D();

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

#ifndef __StdMeshers_mStdMeshers__LayerDistribution2D__
#define __StdMeshers_mStdMeshers__LayerDistribution2D__

  class StdMeshers_LayerDistribution2D;
  class _objref_StdMeshers_LayerDistribution2D;
  class _impl_StdMeshers_LayerDistribution2D;
  
  typedef _objref_StdMeshers_LayerDistribution2D* StdMeshers_LayerDistribution2D_ptr;
  typedef StdMeshers_LayerDistribution2D_ptr StdMeshers_LayerDistribution2DRef;

  class StdMeshers_LayerDistribution2D_Helper {
  public:
    typedef StdMeshers_LayerDistribution2D_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_StdMeshers_LayerDistribution2D, StdMeshers_LayerDistribution2D_Helper> StdMeshers_LayerDistribution2D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_LayerDistribution2D,StdMeshers_LayerDistribution2D_Helper > StdMeshers_LayerDistribution2D_out;

#endif

  // interface StdMeshers_LayerDistribution2D
  class StdMeshers_LayerDistribution2D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_LayerDistribution2D_ptr _ptr_type;
    typedef StdMeshers_LayerDistribution2D_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_StdMeshers_LayerDistribution2D :
    public virtual _objref_StdMeshers_LayerDistribution
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_LayerDistribution2D();

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

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

    friend class StdMeshers_LayerDistribution2D;
  };

  class _pof_StdMeshers_LayerDistribution2D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_LayerDistribution2D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_LayerDistribution2D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_LayerDistribution2D();

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

  class _impl_StdMeshers_LayerDistribution2D :
    public virtual _impl_StdMeshers_LayerDistribution
  {
  public:
    virtual ~_impl_StdMeshers_LayerDistribution2D();

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

#ifndef __StdMeshers_mStdMeshers__ProjectionSource1D__
#define __StdMeshers_mStdMeshers__ProjectionSource1D__

  class StdMeshers_ProjectionSource1D;
  class _objref_StdMeshers_ProjectionSource1D;
  class _impl_StdMeshers_ProjectionSource1D;
  
  typedef _objref_StdMeshers_ProjectionSource1D* StdMeshers_ProjectionSource1D_ptr;
  typedef StdMeshers_ProjectionSource1D_ptr StdMeshers_ProjectionSource1DRef;

  class StdMeshers_ProjectionSource1D_Helper {
  public:
    typedef StdMeshers_ProjectionSource1D_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_StdMeshers_ProjectionSource1D, StdMeshers_ProjectionSource1D_Helper> StdMeshers_ProjectionSource1D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_ProjectionSource1D,StdMeshers_ProjectionSource1D_Helper > StdMeshers_ProjectionSource1D_out;

#endif

  // interface StdMeshers_ProjectionSource1D
  class StdMeshers_ProjectionSource1D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_ProjectionSource1D_ptr _ptr_type;
    typedef StdMeshers_ProjectionSource1D_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_StdMeshers_ProjectionSource1D :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetSourceEdge(::GEOM::GEOM_Object_ptr edge);
    GEOM::GEOM_Object_ptr GetSourceEdge();
    void SetSourceMesh(::SMESH::SMESH_Mesh_ptr mesh);
    SMESH::SMESH_Mesh_ptr GetSourceMesh();
    void SetVertexAssociation(::GEOM::GEOM_Object_ptr sourceVertex, ::GEOM::GEOM_Object_ptr targetVertex);
    GEOM::GEOM_Object_ptr GetSourceVertex();
    GEOM::GEOM_Object_ptr GetTargetVertex();

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

  protected:
    virtual ~_objref_StdMeshers_ProjectionSource1D();

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

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

    friend class StdMeshers_ProjectionSource1D;
  };

  class _pof_StdMeshers_ProjectionSource1D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_ProjectionSource1D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_ProjectionSource1D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_ProjectionSource1D();

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

  class _impl_StdMeshers_ProjectionSource1D :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_ProjectionSource1D();

    virtual void SetSourceEdge(::GEOM::GEOM_Object_ptr edge) = 0;
    virtual GEOM::GEOM_Object_ptr GetSourceEdge() = 0;
    virtual void SetSourceMesh(::SMESH::SMESH_Mesh_ptr mesh) = 0;
    virtual SMESH::SMESH_Mesh_ptr GetSourceMesh() = 0;
    virtual void SetVertexAssociation(::GEOM::GEOM_Object_ptr sourceVertex, ::GEOM::GEOM_Object_ptr targetVertex) = 0;
    virtual GEOM::GEOM_Object_ptr GetSourceVertex() = 0;
    virtual GEOM::GEOM_Object_ptr GetTargetVertex() = 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_StdMeshers_ProjectionSource1D;

#ifndef __StdMeshers_mStdMeshers__ProjectionSource2D__
#define __StdMeshers_mStdMeshers__ProjectionSource2D__

  class StdMeshers_ProjectionSource2D;
  class _objref_StdMeshers_ProjectionSource2D;
  class _impl_StdMeshers_ProjectionSource2D;
  
  typedef _objref_StdMeshers_ProjectionSource2D* StdMeshers_ProjectionSource2D_ptr;
  typedef StdMeshers_ProjectionSource2D_ptr StdMeshers_ProjectionSource2DRef;

  class StdMeshers_ProjectionSource2D_Helper {
  public:
    typedef StdMeshers_ProjectionSource2D_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_StdMeshers_ProjectionSource2D, StdMeshers_ProjectionSource2D_Helper> StdMeshers_ProjectionSource2D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_ProjectionSource2D,StdMeshers_ProjectionSource2D_Helper > StdMeshers_ProjectionSource2D_out;

#endif

  // interface StdMeshers_ProjectionSource2D
  class StdMeshers_ProjectionSource2D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_ProjectionSource2D_ptr _ptr_type;
    typedef StdMeshers_ProjectionSource2D_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_StdMeshers_ProjectionSource2D :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetSourceFace(::GEOM::GEOM_Object_ptr face);
    GEOM::GEOM_Object_ptr GetSourceFace();
    void SetSourceMesh(::SMESH::SMESH_Mesh_ptr mesh);
    SMESH::SMESH_Mesh_ptr GetSourceMesh();
    void SetVertexAssociation(::GEOM::GEOM_Object_ptr sourceVertex1, ::GEOM::GEOM_Object_ptr sourceVertex2, ::GEOM::GEOM_Object_ptr targetVertex1, ::GEOM::GEOM_Object_ptr targetVertex2);
    GEOM::GEOM_Object_ptr GetSourceVertex(::CORBA::Long i);
    GEOM::GEOM_Object_ptr GetTargetVertex(::CORBA::Long i);

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

  protected:
    virtual ~_objref_StdMeshers_ProjectionSource2D();

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

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

    friend class StdMeshers_ProjectionSource2D;
  };

  class _pof_StdMeshers_ProjectionSource2D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_ProjectionSource2D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_ProjectionSource2D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_ProjectionSource2D();

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

  class _impl_StdMeshers_ProjectionSource2D :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_ProjectionSource2D();

    virtual void SetSourceFace(::GEOM::GEOM_Object_ptr face) = 0;
    virtual GEOM::GEOM_Object_ptr GetSourceFace() = 0;
    virtual void SetSourceMesh(::SMESH::SMESH_Mesh_ptr mesh) = 0;
    virtual SMESH::SMESH_Mesh_ptr GetSourceMesh() = 0;
    virtual void SetVertexAssociation(::GEOM::GEOM_Object_ptr sourceVertex1, ::GEOM::GEOM_Object_ptr sourceVertex2, ::GEOM::GEOM_Object_ptr targetVertex1, ::GEOM::GEOM_Object_ptr targetVertex2) = 0;
    virtual GEOM::GEOM_Object_ptr GetSourceVertex(::CORBA::Long i) = 0;
    virtual GEOM::GEOM_Object_ptr GetTargetVertex(::CORBA::Long i) = 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_StdMeshers_ProjectionSource2D;

#ifndef __StdMeshers_mStdMeshers__ProjectionSource3D__
#define __StdMeshers_mStdMeshers__ProjectionSource3D__

  class StdMeshers_ProjectionSource3D;
  class _objref_StdMeshers_ProjectionSource3D;
  class _impl_StdMeshers_ProjectionSource3D;
  
  typedef _objref_StdMeshers_ProjectionSource3D* StdMeshers_ProjectionSource3D_ptr;
  typedef StdMeshers_ProjectionSource3D_ptr StdMeshers_ProjectionSource3DRef;

  class StdMeshers_ProjectionSource3D_Helper {
  public:
    typedef StdMeshers_ProjectionSource3D_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_StdMeshers_ProjectionSource3D, StdMeshers_ProjectionSource3D_Helper> StdMeshers_ProjectionSource3D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_ProjectionSource3D,StdMeshers_ProjectionSource3D_Helper > StdMeshers_ProjectionSource3D_out;

#endif

  // interface StdMeshers_ProjectionSource3D
  class StdMeshers_ProjectionSource3D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_ProjectionSource3D_ptr _ptr_type;
    typedef StdMeshers_ProjectionSource3D_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_StdMeshers_ProjectionSource3D :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetSource3DShape(::GEOM::GEOM_Object_ptr shape);
    GEOM::GEOM_Object_ptr GetSource3DShape();
    void SetSourceMesh(::SMESH::SMESH_Mesh_ptr mesh);
    SMESH::SMESH_Mesh_ptr GetSourceMesh();
    void SetVertexAssociation(::GEOM::GEOM_Object_ptr sourceVertex1, ::GEOM::GEOM_Object_ptr sourceVertex2, ::GEOM::GEOM_Object_ptr targetVertex1, ::GEOM::GEOM_Object_ptr targetVertex2);
    GEOM::GEOM_Object_ptr GetSourceVertex(::CORBA::Long i);
    GEOM::GEOM_Object_ptr GetTargetVertex(::CORBA::Long i);

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

  protected:
    virtual ~_objref_StdMeshers_ProjectionSource3D();

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

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

    friend class StdMeshers_ProjectionSource3D;
  };

  class _pof_StdMeshers_ProjectionSource3D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_ProjectionSource3D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_ProjectionSource3D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_ProjectionSource3D();

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

  class _impl_StdMeshers_ProjectionSource3D :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_ProjectionSource3D();

    virtual void SetSource3DShape(::GEOM::GEOM_Object_ptr shape) = 0;
    virtual GEOM::GEOM_Object_ptr GetSource3DShape() = 0;
    virtual void SetSourceMesh(::SMESH::SMESH_Mesh_ptr mesh) = 0;
    virtual SMESH::SMESH_Mesh_ptr GetSourceMesh() = 0;
    virtual void SetVertexAssociation(::GEOM::GEOM_Object_ptr sourceVertex1, ::GEOM::GEOM_Object_ptr sourceVertex2, ::GEOM::GEOM_Object_ptr targetVertex1, ::GEOM::GEOM_Object_ptr targetVertex2) = 0;
    virtual GEOM::GEOM_Object_ptr GetSourceVertex(::CORBA::Long i) = 0;
    virtual GEOM::GEOM_Object_ptr GetTargetVertex(::CORBA::Long i) = 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_StdMeshers_ProjectionSource3D;

#ifndef __StdMeshers_mStdMeshers__SegmentLengthAroundVertex__
#define __StdMeshers_mStdMeshers__SegmentLengthAroundVertex__

  class StdMeshers_SegmentLengthAroundVertex;
  class _objref_StdMeshers_SegmentLengthAroundVertex;
  class _impl_StdMeshers_SegmentLengthAroundVertex;
  
  typedef _objref_StdMeshers_SegmentLengthAroundVertex* StdMeshers_SegmentLengthAroundVertex_ptr;
  typedef StdMeshers_SegmentLengthAroundVertex_ptr StdMeshers_SegmentLengthAroundVertexRef;

  class StdMeshers_SegmentLengthAroundVertex_Helper {
  public:
    typedef StdMeshers_SegmentLengthAroundVertex_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_StdMeshers_SegmentLengthAroundVertex, StdMeshers_SegmentLengthAroundVertex_Helper> StdMeshers_SegmentLengthAroundVertex_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_SegmentLengthAroundVertex,StdMeshers_SegmentLengthAroundVertex_Helper > StdMeshers_SegmentLengthAroundVertex_out;

#endif

  // interface StdMeshers_SegmentLengthAroundVertex
  class StdMeshers_SegmentLengthAroundVertex {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_SegmentLengthAroundVertex_ptr _ptr_type;
    typedef StdMeshers_SegmentLengthAroundVertex_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_StdMeshers_SegmentLengthAroundVertex :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetLength(::CORBA::Double length);
    ::CORBA::Double GetLength();

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

  protected:
    virtual ~_objref_StdMeshers_SegmentLengthAroundVertex();

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

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

    friend class StdMeshers_SegmentLengthAroundVertex;
  };

  class _pof_StdMeshers_SegmentLengthAroundVertex : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_SegmentLengthAroundVertex() : _OMNI_NS(proxyObjectFactory)(StdMeshers_SegmentLengthAroundVertex::_PD_repoId) {}
    virtual ~_pof_StdMeshers_SegmentLengthAroundVertex();

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

  class _impl_StdMeshers_SegmentLengthAroundVertex :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_SegmentLengthAroundVertex();

    virtual void SetLength(::CORBA::Double length) = 0;
    virtual ::CORBA::Double GetLength() = 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_StdMeshers_SegmentLengthAroundVertex;

#ifndef __StdMeshers_mStdMeshers__QuadrangleParams__
#define __StdMeshers_mStdMeshers__QuadrangleParams__

  class StdMeshers_QuadrangleParams;
  class _objref_StdMeshers_QuadrangleParams;
  class _impl_StdMeshers_QuadrangleParams;
  
  typedef _objref_StdMeshers_QuadrangleParams* StdMeshers_QuadrangleParams_ptr;
  typedef StdMeshers_QuadrangleParams_ptr StdMeshers_QuadrangleParamsRef;

  class StdMeshers_QuadrangleParams_Helper {
  public:
    typedef StdMeshers_QuadrangleParams_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_StdMeshers_QuadrangleParams, StdMeshers_QuadrangleParams_Helper> StdMeshers_QuadrangleParams_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_QuadrangleParams,StdMeshers_QuadrangleParams_Helper > StdMeshers_QuadrangleParams_out;

#endif

  // interface StdMeshers_QuadrangleParams
  class StdMeshers_QuadrangleParams {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_QuadrangleParams_ptr _ptr_type;
    typedef StdMeshers_QuadrangleParams_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_StdMeshers_QuadrangleParams :
    public virtual SMESH::_objref_SMESH_Hypothesis
  {
  public:
    void SetTriaVertex(::CORBA::Long vertID);
    ::CORBA::Long GetTriaVertex();
    void SetObjectEntry(const char* entry);
    char* GetObjectEntry();

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

  protected:
    virtual ~_objref_StdMeshers_QuadrangleParams();

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

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

    friend class StdMeshers_QuadrangleParams;
  };

  class _pof_StdMeshers_QuadrangleParams : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_QuadrangleParams() : _OMNI_NS(proxyObjectFactory)(StdMeshers_QuadrangleParams::_PD_repoId) {}
    virtual ~_pof_StdMeshers_QuadrangleParams();

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

  class _impl_StdMeshers_QuadrangleParams :
    public virtual SMESH::_impl_SMESH_Hypothesis
  {
  public:
    virtual ~_impl_StdMeshers_QuadrangleParams();

    virtual void SetTriaVertex(::CORBA::Long vertID) = 0;
    virtual ::CORBA::Long GetTriaVertex() = 0;
    virtual void SetObjectEntry(const char* entry) = 0;
    virtual char* GetObjectEntry() = 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_StdMeshers_QuadrangleParams;

#ifndef __StdMeshers_mStdMeshers__SegmentAroundVertex__0D__
#define __StdMeshers_mStdMeshers__SegmentAroundVertex__0D__

  class StdMeshers_SegmentAroundVertex_0D;
  class _objref_StdMeshers_SegmentAroundVertex_0D;
  class _impl_StdMeshers_SegmentAroundVertex_0D;
  
  typedef _objref_StdMeshers_SegmentAroundVertex_0D* StdMeshers_SegmentAroundVertex_0D_ptr;
  typedef StdMeshers_SegmentAroundVertex_0D_ptr StdMeshers_SegmentAroundVertex_0DRef;

  class StdMeshers_SegmentAroundVertex_0D_Helper {
  public:
    typedef StdMeshers_SegmentAroundVertex_0D_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_StdMeshers_SegmentAroundVertex_0D, StdMeshers_SegmentAroundVertex_0D_Helper> StdMeshers_SegmentAroundVertex_0D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_SegmentAroundVertex_0D,StdMeshers_SegmentAroundVertex_0D_Helper > StdMeshers_SegmentAroundVertex_0D_out;

#endif

  // interface StdMeshers_SegmentAroundVertex_0D
  class StdMeshers_SegmentAroundVertex_0D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_SegmentAroundVertex_0D_ptr _ptr_type;
    typedef StdMeshers_SegmentAroundVertex_0D_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_StdMeshers_SegmentAroundVertex_0D :
    public virtual SMESH::_objref_SMESH_0D_Algo
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_SegmentAroundVertex_0D();

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

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

    friend class StdMeshers_SegmentAroundVertex_0D;
  };

  class _pof_StdMeshers_SegmentAroundVertex_0D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_SegmentAroundVertex_0D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_SegmentAroundVertex_0D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_SegmentAroundVertex_0D();

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

  class _impl_StdMeshers_SegmentAroundVertex_0D :
    public virtual SMESH::_impl_SMESH_0D_Algo
  {
  public:
    virtual ~_impl_StdMeshers_SegmentAroundVertex_0D();

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

#ifndef __StdMeshers_mStdMeshers__Regular__1D__
#define __StdMeshers_mStdMeshers__Regular__1D__

  class StdMeshers_Regular_1D;
  class _objref_StdMeshers_Regular_1D;
  class _impl_StdMeshers_Regular_1D;
  
  typedef _objref_StdMeshers_Regular_1D* StdMeshers_Regular_1D_ptr;
  typedef StdMeshers_Regular_1D_ptr StdMeshers_Regular_1DRef;

  class StdMeshers_Regular_1D_Helper {
  public:
    typedef StdMeshers_Regular_1D_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_StdMeshers_Regular_1D, StdMeshers_Regular_1D_Helper> StdMeshers_Regular_1D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_Regular_1D,StdMeshers_Regular_1D_Helper > StdMeshers_Regular_1D_out;

#endif

  // interface StdMeshers_Regular_1D
  class StdMeshers_Regular_1D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_Regular_1D_ptr _ptr_type;
    typedef StdMeshers_Regular_1D_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_StdMeshers_Regular_1D :
    public virtual SMESH::_objref_SMESH_1D_Algo
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_Regular_1D();

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

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

    friend class StdMeshers_Regular_1D;
  };

  class _pof_StdMeshers_Regular_1D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_Regular_1D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_Regular_1D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_Regular_1D();

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

  class _impl_StdMeshers_Regular_1D :
    public virtual SMESH::_impl_SMESH_1D_Algo
  {
  public:
    virtual ~_impl_StdMeshers_Regular_1D();

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

#ifndef __StdMeshers_mStdMeshers__CompositeSegment__1D__
#define __StdMeshers_mStdMeshers__CompositeSegment__1D__

  class StdMeshers_CompositeSegment_1D;
  class _objref_StdMeshers_CompositeSegment_1D;
  class _impl_StdMeshers_CompositeSegment_1D;
  
  typedef _objref_StdMeshers_CompositeSegment_1D* StdMeshers_CompositeSegment_1D_ptr;
  typedef StdMeshers_CompositeSegment_1D_ptr StdMeshers_CompositeSegment_1DRef;

  class StdMeshers_CompositeSegment_1D_Helper {
  public:
    typedef StdMeshers_CompositeSegment_1D_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_StdMeshers_CompositeSegment_1D, StdMeshers_CompositeSegment_1D_Helper> StdMeshers_CompositeSegment_1D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_CompositeSegment_1D,StdMeshers_CompositeSegment_1D_Helper > StdMeshers_CompositeSegment_1D_out;

#endif

  // interface StdMeshers_CompositeSegment_1D
  class StdMeshers_CompositeSegment_1D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_CompositeSegment_1D_ptr _ptr_type;
    typedef StdMeshers_CompositeSegment_1D_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_StdMeshers_CompositeSegment_1D :
    public virtual SMESH::_objref_SMESH_1D_Algo
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_CompositeSegment_1D();

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

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

    friend class StdMeshers_CompositeSegment_1D;
  };

  class _pof_StdMeshers_CompositeSegment_1D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_CompositeSegment_1D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_CompositeSegment_1D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_CompositeSegment_1D();

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

  class _impl_StdMeshers_CompositeSegment_1D :
    public virtual SMESH::_impl_SMESH_1D_Algo
  {
  public:
    virtual ~_impl_StdMeshers_CompositeSegment_1D();

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

#ifndef __StdMeshers_mStdMeshers__MEFISTO__2D__
#define __StdMeshers_mStdMeshers__MEFISTO__2D__

  class StdMeshers_MEFISTO_2D;
  class _objref_StdMeshers_MEFISTO_2D;
  class _impl_StdMeshers_MEFISTO_2D;
  
  typedef _objref_StdMeshers_MEFISTO_2D* StdMeshers_MEFISTO_2D_ptr;
  typedef StdMeshers_MEFISTO_2D_ptr StdMeshers_MEFISTO_2DRef;

  class StdMeshers_MEFISTO_2D_Helper {
  public:
    typedef StdMeshers_MEFISTO_2D_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_StdMeshers_MEFISTO_2D, StdMeshers_MEFISTO_2D_Helper> StdMeshers_MEFISTO_2D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_MEFISTO_2D,StdMeshers_MEFISTO_2D_Helper > StdMeshers_MEFISTO_2D_out;

#endif

  // interface StdMeshers_MEFISTO_2D
  class StdMeshers_MEFISTO_2D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_MEFISTO_2D_ptr _ptr_type;
    typedef StdMeshers_MEFISTO_2D_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_StdMeshers_MEFISTO_2D :
    public virtual SMESH::_objref_SMESH_2D_Algo
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_MEFISTO_2D();

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

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

    friend class StdMeshers_MEFISTO_2D;
  };

  class _pof_StdMeshers_MEFISTO_2D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_MEFISTO_2D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_MEFISTO_2D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_MEFISTO_2D();

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

  class _impl_StdMeshers_MEFISTO_2D :
    public virtual SMESH::_impl_SMESH_2D_Algo
  {
  public:
    virtual ~_impl_StdMeshers_MEFISTO_2D();

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

#ifndef __StdMeshers_mStdMeshers__Quadrangle__2D__
#define __StdMeshers_mStdMeshers__Quadrangle__2D__

  class StdMeshers_Quadrangle_2D;
  class _objref_StdMeshers_Quadrangle_2D;
  class _impl_StdMeshers_Quadrangle_2D;
  
  typedef _objref_StdMeshers_Quadrangle_2D* StdMeshers_Quadrangle_2D_ptr;
  typedef StdMeshers_Quadrangle_2D_ptr StdMeshers_Quadrangle_2DRef;

  class StdMeshers_Quadrangle_2D_Helper {
  public:
    typedef StdMeshers_Quadrangle_2D_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_StdMeshers_Quadrangle_2D, StdMeshers_Quadrangle_2D_Helper> StdMeshers_Quadrangle_2D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_Quadrangle_2D,StdMeshers_Quadrangle_2D_Helper > StdMeshers_Quadrangle_2D_out;

#endif

  // interface StdMeshers_Quadrangle_2D
  class StdMeshers_Quadrangle_2D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_Quadrangle_2D_ptr _ptr_type;
    typedef StdMeshers_Quadrangle_2D_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_StdMeshers_Quadrangle_2D :
    public virtual SMESH::_objref_SMESH_2D_Algo
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_Quadrangle_2D();

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

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

    friend class StdMeshers_Quadrangle_2D;
  };

  class _pof_StdMeshers_Quadrangle_2D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_Quadrangle_2D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_Quadrangle_2D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_Quadrangle_2D();

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

  class _impl_StdMeshers_Quadrangle_2D :
    public virtual SMESH::_impl_SMESH_2D_Algo
  {
  public:
    virtual ~_impl_StdMeshers_Quadrangle_2D();

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

#ifndef __StdMeshers_mStdMeshers__Hexa__3D__
#define __StdMeshers_mStdMeshers__Hexa__3D__

  class StdMeshers_Hexa_3D;
  class _objref_StdMeshers_Hexa_3D;
  class _impl_StdMeshers_Hexa_3D;
  
  typedef _objref_StdMeshers_Hexa_3D* StdMeshers_Hexa_3D_ptr;
  typedef StdMeshers_Hexa_3D_ptr StdMeshers_Hexa_3DRef;

  class StdMeshers_Hexa_3D_Helper {
  public:
    typedef StdMeshers_Hexa_3D_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_StdMeshers_Hexa_3D, StdMeshers_Hexa_3D_Helper> StdMeshers_Hexa_3D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_Hexa_3D,StdMeshers_Hexa_3D_Helper > StdMeshers_Hexa_3D_out;

#endif

  // interface StdMeshers_Hexa_3D
  class StdMeshers_Hexa_3D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_Hexa_3D_ptr _ptr_type;
    typedef StdMeshers_Hexa_3D_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_StdMeshers_Hexa_3D :
    public virtual SMESH::_objref_SMESH_3D_Algo
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_Hexa_3D();

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

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

    friend class StdMeshers_Hexa_3D;
  };

  class _pof_StdMeshers_Hexa_3D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_Hexa_3D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_Hexa_3D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_Hexa_3D();

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

  class _impl_StdMeshers_Hexa_3D :
    public virtual SMESH::_impl_SMESH_3D_Algo
  {
  public:
    virtual ~_impl_StdMeshers_Hexa_3D();

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

#ifndef __StdMeshers_mStdMeshers__Prism__3D__
#define __StdMeshers_mStdMeshers__Prism__3D__

  class StdMeshers_Prism_3D;
  class _objref_StdMeshers_Prism_3D;
  class _impl_StdMeshers_Prism_3D;
  
  typedef _objref_StdMeshers_Prism_3D* StdMeshers_Prism_3D_ptr;
  typedef StdMeshers_Prism_3D_ptr StdMeshers_Prism_3DRef;

  class StdMeshers_Prism_3D_Helper {
  public:
    typedef StdMeshers_Prism_3D_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_StdMeshers_Prism_3D, StdMeshers_Prism_3D_Helper> StdMeshers_Prism_3D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_Prism_3D,StdMeshers_Prism_3D_Helper > StdMeshers_Prism_3D_out;

#endif

  // interface StdMeshers_Prism_3D
  class StdMeshers_Prism_3D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_Prism_3D_ptr _ptr_type;
    typedef StdMeshers_Prism_3D_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_StdMeshers_Prism_3D :
    public virtual SMESH::_objref_SMESH_3D_Algo
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_Prism_3D();

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

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

    friend class StdMeshers_Prism_3D;
  };

  class _pof_StdMeshers_Prism_3D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_Prism_3D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_Prism_3D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_Prism_3D();

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

  class _impl_StdMeshers_Prism_3D :
    public virtual SMESH::_impl_SMESH_3D_Algo
  {
  public:
    virtual ~_impl_StdMeshers_Prism_3D();

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

#ifndef __StdMeshers_mStdMeshers__RadialPrism__3D__
#define __StdMeshers_mStdMeshers__RadialPrism__3D__

  class StdMeshers_RadialPrism_3D;
  class _objref_StdMeshers_RadialPrism_3D;
  class _impl_StdMeshers_RadialPrism_3D;
  
  typedef _objref_StdMeshers_RadialPrism_3D* StdMeshers_RadialPrism_3D_ptr;
  typedef StdMeshers_RadialPrism_3D_ptr StdMeshers_RadialPrism_3DRef;

  class StdMeshers_RadialPrism_3D_Helper {
  public:
    typedef StdMeshers_RadialPrism_3D_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_StdMeshers_RadialPrism_3D, StdMeshers_RadialPrism_3D_Helper> StdMeshers_RadialPrism_3D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_RadialPrism_3D,StdMeshers_RadialPrism_3D_Helper > StdMeshers_RadialPrism_3D_out;

#endif

  // interface StdMeshers_RadialPrism_3D
  class StdMeshers_RadialPrism_3D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_RadialPrism_3D_ptr _ptr_type;
    typedef StdMeshers_RadialPrism_3D_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_StdMeshers_RadialPrism_3D :
    public virtual SMESH::_objref_SMESH_3D_Algo
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_RadialPrism_3D();

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

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

    friend class StdMeshers_RadialPrism_3D;
  };

  class _pof_StdMeshers_RadialPrism_3D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_RadialPrism_3D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_RadialPrism_3D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_RadialPrism_3D();

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

  class _impl_StdMeshers_RadialPrism_3D :
    public virtual SMESH::_impl_SMESH_3D_Algo
  {
  public:
    virtual ~_impl_StdMeshers_RadialPrism_3D();

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

#ifndef __StdMeshers_mStdMeshers__Projection__3D__
#define __StdMeshers_mStdMeshers__Projection__3D__

  class StdMeshers_Projection_3D;
  class _objref_StdMeshers_Projection_3D;
  class _impl_StdMeshers_Projection_3D;
  
  typedef _objref_StdMeshers_Projection_3D* StdMeshers_Projection_3D_ptr;
  typedef StdMeshers_Projection_3D_ptr StdMeshers_Projection_3DRef;

  class StdMeshers_Projection_3D_Helper {
  public:
    typedef StdMeshers_Projection_3D_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_StdMeshers_Projection_3D, StdMeshers_Projection_3D_Helper> StdMeshers_Projection_3D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_Projection_3D,StdMeshers_Projection_3D_Helper > StdMeshers_Projection_3D_out;

#endif

  // interface StdMeshers_Projection_3D
  class StdMeshers_Projection_3D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_Projection_3D_ptr _ptr_type;
    typedef StdMeshers_Projection_3D_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_StdMeshers_Projection_3D :
    public virtual SMESH::_objref_SMESH_3D_Algo
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_Projection_3D();

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

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

    friend class StdMeshers_Projection_3D;
  };

  class _pof_StdMeshers_Projection_3D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_Projection_3D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_Projection_3D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_Projection_3D();

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

  class _impl_StdMeshers_Projection_3D :
    public virtual SMESH::_impl_SMESH_3D_Algo
  {
  public:
    virtual ~_impl_StdMeshers_Projection_3D();

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

#ifndef __StdMeshers_mStdMeshers__Projection__2D__
#define __StdMeshers_mStdMeshers__Projection__2D__

  class StdMeshers_Projection_2D;
  class _objref_StdMeshers_Projection_2D;
  class _impl_StdMeshers_Projection_2D;
  
  typedef _objref_StdMeshers_Projection_2D* StdMeshers_Projection_2D_ptr;
  typedef StdMeshers_Projection_2D_ptr StdMeshers_Projection_2DRef;

  class StdMeshers_Projection_2D_Helper {
  public:
    typedef StdMeshers_Projection_2D_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_StdMeshers_Projection_2D, StdMeshers_Projection_2D_Helper> StdMeshers_Projection_2D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_Projection_2D,StdMeshers_Projection_2D_Helper > StdMeshers_Projection_2D_out;

#endif

  // interface StdMeshers_Projection_2D
  class StdMeshers_Projection_2D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_Projection_2D_ptr _ptr_type;
    typedef StdMeshers_Projection_2D_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_StdMeshers_Projection_2D :
    public virtual SMESH::_objref_SMESH_2D_Algo
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_Projection_2D();

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

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

    friend class StdMeshers_Projection_2D;
  };

  class _pof_StdMeshers_Projection_2D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_Projection_2D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_Projection_2D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_Projection_2D();

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

  class _impl_StdMeshers_Projection_2D :
    public virtual SMESH::_impl_SMESH_2D_Algo
  {
  public:
    virtual ~_impl_StdMeshers_Projection_2D();

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

#ifndef __StdMeshers_mStdMeshers__Projection__1D__
#define __StdMeshers_mStdMeshers__Projection__1D__

  class StdMeshers_Projection_1D;
  class _objref_StdMeshers_Projection_1D;
  class _impl_StdMeshers_Projection_1D;
  
  typedef _objref_StdMeshers_Projection_1D* StdMeshers_Projection_1D_ptr;
  typedef StdMeshers_Projection_1D_ptr StdMeshers_Projection_1DRef;

  class StdMeshers_Projection_1D_Helper {
  public:
    typedef StdMeshers_Projection_1D_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_StdMeshers_Projection_1D, StdMeshers_Projection_1D_Helper> StdMeshers_Projection_1D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_Projection_1D,StdMeshers_Projection_1D_Helper > StdMeshers_Projection_1D_out;

#endif

  // interface StdMeshers_Projection_1D
  class StdMeshers_Projection_1D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_Projection_1D_ptr _ptr_type;
    typedef StdMeshers_Projection_1D_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_StdMeshers_Projection_1D :
    public virtual SMESH::_objref_SMESH_1D_Algo
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_Projection_1D();

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

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

    friend class StdMeshers_Projection_1D;
  };

  class _pof_StdMeshers_Projection_1D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_Projection_1D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_Projection_1D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_Projection_1D();

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

  class _impl_StdMeshers_Projection_1D :
    public virtual SMESH::_impl_SMESH_1D_Algo
  {
  public:
    virtual ~_impl_StdMeshers_Projection_1D();

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

#ifndef __StdMeshers_mStdMeshers__UseExisting__2D__
#define __StdMeshers_mStdMeshers__UseExisting__2D__

  class StdMeshers_UseExisting_2D;
  class _objref_StdMeshers_UseExisting_2D;
  class _impl_StdMeshers_UseExisting_2D;
  
  typedef _objref_StdMeshers_UseExisting_2D* StdMeshers_UseExisting_2D_ptr;
  typedef StdMeshers_UseExisting_2D_ptr StdMeshers_UseExisting_2DRef;

  class StdMeshers_UseExisting_2D_Helper {
  public:
    typedef StdMeshers_UseExisting_2D_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_StdMeshers_UseExisting_2D, StdMeshers_UseExisting_2D_Helper> StdMeshers_UseExisting_2D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_UseExisting_2D,StdMeshers_UseExisting_2D_Helper > StdMeshers_UseExisting_2D_out;

#endif

  // interface StdMeshers_UseExisting_2D
  class StdMeshers_UseExisting_2D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_UseExisting_2D_ptr _ptr_type;
    typedef StdMeshers_UseExisting_2D_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_StdMeshers_UseExisting_2D :
    public virtual SMESH::_objref_SMESH_2D_Algo
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_UseExisting_2D();

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

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

    friend class StdMeshers_UseExisting_2D;
  };

  class _pof_StdMeshers_UseExisting_2D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_UseExisting_2D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_UseExisting_2D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_UseExisting_2D();

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

  class _impl_StdMeshers_UseExisting_2D :
    public virtual SMESH::_impl_SMESH_2D_Algo
  {
  public:
    virtual ~_impl_StdMeshers_UseExisting_2D();

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

#ifndef __StdMeshers_mStdMeshers__UseExisting__1D__
#define __StdMeshers_mStdMeshers__UseExisting__1D__

  class StdMeshers_UseExisting_1D;
  class _objref_StdMeshers_UseExisting_1D;
  class _impl_StdMeshers_UseExisting_1D;
  
  typedef _objref_StdMeshers_UseExisting_1D* StdMeshers_UseExisting_1D_ptr;
  typedef StdMeshers_UseExisting_1D_ptr StdMeshers_UseExisting_1DRef;

  class StdMeshers_UseExisting_1D_Helper {
  public:
    typedef StdMeshers_UseExisting_1D_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_StdMeshers_UseExisting_1D, StdMeshers_UseExisting_1D_Helper> StdMeshers_UseExisting_1D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_UseExisting_1D,StdMeshers_UseExisting_1D_Helper > StdMeshers_UseExisting_1D_out;

#endif

  // interface StdMeshers_UseExisting_1D
  class StdMeshers_UseExisting_1D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_UseExisting_1D_ptr _ptr_type;
    typedef StdMeshers_UseExisting_1D_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_StdMeshers_UseExisting_1D :
    public virtual SMESH::_objref_SMESH_1D_Algo
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_UseExisting_1D();

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

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

    friend class StdMeshers_UseExisting_1D;
  };

  class _pof_StdMeshers_UseExisting_1D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_UseExisting_1D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_UseExisting_1D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_UseExisting_1D();

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

  class _impl_StdMeshers_UseExisting_1D :
    public virtual SMESH::_impl_SMESH_1D_Algo
  {
  public:
    virtual ~_impl_StdMeshers_UseExisting_1D();

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

#ifndef __StdMeshers_mStdMeshers__RadialQuadrangle__1D2D__
#define __StdMeshers_mStdMeshers__RadialQuadrangle__1D2D__

  class StdMeshers_RadialQuadrangle_1D2D;
  class _objref_StdMeshers_RadialQuadrangle_1D2D;
  class _impl_StdMeshers_RadialQuadrangle_1D2D;
  
  typedef _objref_StdMeshers_RadialQuadrangle_1D2D* StdMeshers_RadialQuadrangle_1D2D_ptr;
  typedef StdMeshers_RadialQuadrangle_1D2D_ptr StdMeshers_RadialQuadrangle_1D2DRef;

  class StdMeshers_RadialQuadrangle_1D2D_Helper {
  public:
    typedef StdMeshers_RadialQuadrangle_1D2D_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_StdMeshers_RadialQuadrangle_1D2D, StdMeshers_RadialQuadrangle_1D2D_Helper> StdMeshers_RadialQuadrangle_1D2D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_StdMeshers_RadialQuadrangle_1D2D,StdMeshers_RadialQuadrangle_1D2D_Helper > StdMeshers_RadialQuadrangle_1D2D_out;

#endif

  // interface StdMeshers_RadialQuadrangle_1D2D
  class StdMeshers_RadialQuadrangle_1D2D {
  public:
    // Declarations for this interface type.
    typedef StdMeshers_RadialQuadrangle_1D2D_ptr _ptr_type;
    typedef StdMeshers_RadialQuadrangle_1D2D_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_StdMeshers_RadialQuadrangle_1D2D :
    public virtual SMESH::_objref_SMESH_2D_Algo
  {
  public:
    

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

  protected:
    virtual ~_objref_StdMeshers_RadialQuadrangle_1D2D();

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

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

    friend class StdMeshers_RadialQuadrangle_1D2D;
  };

  class _pof_StdMeshers_RadialQuadrangle_1D2D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_StdMeshers_RadialQuadrangle_1D2D() : _OMNI_NS(proxyObjectFactory)(StdMeshers_RadialQuadrangle_1D2D::_PD_repoId) {}
    virtual ~_pof_StdMeshers_RadialQuadrangle_1D2D();

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

  class _impl_StdMeshers_RadialQuadrangle_1D2D :
    public virtual SMESH::_impl_SMESH_2D_Algo
  {
  public:
    virtual ~_impl_StdMeshers_RadialQuadrangle_1D2D();

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

_CORBA_MODULE_END



_CORBA_MODULE POA_StdMeshers
_CORBA_MODULE_BEG

  class StdMeshers_LocalLength :
    public virtual StdMeshers::_impl_StdMeshers_LocalLength,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_LocalLength();

    inline ::StdMeshers::StdMeshers_LocalLength_ptr _this() {
      return (::StdMeshers::StdMeshers_LocalLength_ptr) _do_this(::StdMeshers::StdMeshers_LocalLength::_PD_repoId);
    }
  };

  class StdMeshers_MaxLength :
    public virtual StdMeshers::_impl_StdMeshers_MaxLength,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_MaxLength();

    inline ::StdMeshers::StdMeshers_MaxLength_ptr _this() {
      return (::StdMeshers::StdMeshers_MaxLength_ptr) _do_this(::StdMeshers::StdMeshers_MaxLength::_PD_repoId);
    }
  };

  class StdMeshers_AutomaticLength :
    public virtual StdMeshers::_impl_StdMeshers_AutomaticLength,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_AutomaticLength();

    inline ::StdMeshers::StdMeshers_AutomaticLength_ptr _this() {
      return (::StdMeshers::StdMeshers_AutomaticLength_ptr) _do_this(::StdMeshers::StdMeshers_AutomaticLength::_PD_repoId);
    }
  };

  class StdMeshers_NumberOfSegments :
    public virtual StdMeshers::_impl_StdMeshers_NumberOfSegments,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_NumberOfSegments();

    inline ::StdMeshers::StdMeshers_NumberOfSegments_ptr _this() {
      return (::StdMeshers::StdMeshers_NumberOfSegments_ptr) _do_this(::StdMeshers::StdMeshers_NumberOfSegments::_PD_repoId);
    }
  };

  class StdMeshers_Arithmetic1D :
    public virtual StdMeshers::_impl_StdMeshers_Arithmetic1D,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_Arithmetic1D();

    inline ::StdMeshers::StdMeshers_Arithmetic1D_ptr _this() {
      return (::StdMeshers::StdMeshers_Arithmetic1D_ptr) _do_this(::StdMeshers::StdMeshers_Arithmetic1D::_PD_repoId);
    }
  };

  class StdMeshers_MaxElementArea :
    public virtual StdMeshers::_impl_StdMeshers_MaxElementArea,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_MaxElementArea();

    inline ::StdMeshers::StdMeshers_MaxElementArea_ptr _this() {
      return (::StdMeshers::StdMeshers_MaxElementArea_ptr) _do_this(::StdMeshers::StdMeshers_MaxElementArea::_PD_repoId);
    }
  };

  class StdMeshers_LengthFromEdges :
    public virtual StdMeshers::_impl_StdMeshers_LengthFromEdges,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_LengthFromEdges();

    inline ::StdMeshers::StdMeshers_LengthFromEdges_ptr _this() {
      return (::StdMeshers::StdMeshers_LengthFromEdges_ptr) _do_this(::StdMeshers::StdMeshers_LengthFromEdges::_PD_repoId);
    }
  };

  class StdMeshers_StartEndLength :
    public virtual StdMeshers::_impl_StdMeshers_StartEndLength,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_StartEndLength();

    inline ::StdMeshers::StdMeshers_StartEndLength_ptr _this() {
      return (::StdMeshers::StdMeshers_StartEndLength_ptr) _do_this(::StdMeshers::StdMeshers_StartEndLength::_PD_repoId);
    }
  };

  class StdMeshers_Deflection1D :
    public virtual StdMeshers::_impl_StdMeshers_Deflection1D,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_Deflection1D();

    inline ::StdMeshers::StdMeshers_Deflection1D_ptr _this() {
      return (::StdMeshers::StdMeshers_Deflection1D_ptr) _do_this(::StdMeshers::StdMeshers_Deflection1D::_PD_repoId);
    }
  };

  class StdMeshers_FixedPoints1D :
    public virtual StdMeshers::_impl_StdMeshers_FixedPoints1D,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_FixedPoints1D();

    inline ::StdMeshers::StdMeshers_FixedPoints1D_ptr _this() {
      return (::StdMeshers::StdMeshers_FixedPoints1D_ptr) _do_this(::StdMeshers::StdMeshers_FixedPoints1D::_PD_repoId);
    }
  };

  class StdMeshers_MaxElementVolume :
    public virtual StdMeshers::_impl_StdMeshers_MaxElementVolume,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_MaxElementVolume();

    inline ::StdMeshers::StdMeshers_MaxElementVolume_ptr _this() {
      return (::StdMeshers::StdMeshers_MaxElementVolume_ptr) _do_this(::StdMeshers::StdMeshers_MaxElementVolume::_PD_repoId);
    }
  };

  class StdMeshers_NotConformAllowed :
    public virtual StdMeshers::_impl_StdMeshers_NotConformAllowed,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_NotConformAllowed();

    inline ::StdMeshers::StdMeshers_NotConformAllowed_ptr _this() {
      return (::StdMeshers::StdMeshers_NotConformAllowed_ptr) _do_this(::StdMeshers::StdMeshers_NotConformAllowed::_PD_repoId);
    }
  };

  class StdMeshers_Propagation :
    public virtual StdMeshers::_impl_StdMeshers_Propagation,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_Propagation();

    inline ::StdMeshers::StdMeshers_Propagation_ptr _this() {
      return (::StdMeshers::StdMeshers_Propagation_ptr) _do_this(::StdMeshers::StdMeshers_Propagation::_PD_repoId);
    }
  };

  class StdMeshers_QuadranglePreference :
    public virtual StdMeshers::_impl_StdMeshers_QuadranglePreference,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_QuadranglePreference();

    inline ::StdMeshers::StdMeshers_QuadranglePreference_ptr _this() {
      return (::StdMeshers::StdMeshers_QuadranglePreference_ptr) _do_this(::StdMeshers::StdMeshers_QuadranglePreference::_PD_repoId);
    }
  };

  class StdMeshers_TrianglePreference :
    public virtual StdMeshers::_impl_StdMeshers_TrianglePreference,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_TrianglePreference();

    inline ::StdMeshers::StdMeshers_TrianglePreference_ptr _this() {
      return (::StdMeshers::StdMeshers_TrianglePreference_ptr) _do_this(::StdMeshers::StdMeshers_TrianglePreference::_PD_repoId);
    }
  };

  class StdMeshers_QuadraticMesh :
    public virtual StdMeshers::_impl_StdMeshers_QuadraticMesh,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_QuadraticMesh();

    inline ::StdMeshers::StdMeshers_QuadraticMesh_ptr _this() {
      return (::StdMeshers::StdMeshers_QuadraticMesh_ptr) _do_this(::StdMeshers::StdMeshers_QuadraticMesh::_PD_repoId);
    }
  };

  class StdMeshers_NumberOfLayers :
    public virtual StdMeshers::_impl_StdMeshers_NumberOfLayers,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_NumberOfLayers();

    inline ::StdMeshers::StdMeshers_NumberOfLayers_ptr _this() {
      return (::StdMeshers::StdMeshers_NumberOfLayers_ptr) _do_this(::StdMeshers::StdMeshers_NumberOfLayers::_PD_repoId);
    }
  };

  class StdMeshers_LayerDistribution :
    public virtual StdMeshers::_impl_StdMeshers_LayerDistribution,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_LayerDistribution();

    inline ::StdMeshers::StdMeshers_LayerDistribution_ptr _this() {
      return (::StdMeshers::StdMeshers_LayerDistribution_ptr) _do_this(::StdMeshers::StdMeshers_LayerDistribution::_PD_repoId);
    }
  };

  class StdMeshers_NumberOfLayers2D :
    public virtual StdMeshers::_impl_StdMeshers_NumberOfLayers2D,
    public virtual StdMeshers_NumberOfLayers
  {
  public:
    virtual ~StdMeshers_NumberOfLayers2D();

    inline ::StdMeshers::StdMeshers_NumberOfLayers2D_ptr _this() {
      return (::StdMeshers::StdMeshers_NumberOfLayers2D_ptr) _do_this(::StdMeshers::StdMeshers_NumberOfLayers2D::_PD_repoId);
    }
  };

  class StdMeshers_LayerDistribution2D :
    public virtual StdMeshers::_impl_StdMeshers_LayerDistribution2D,
    public virtual StdMeshers_LayerDistribution
  {
  public:
    virtual ~StdMeshers_LayerDistribution2D();

    inline ::StdMeshers::StdMeshers_LayerDistribution2D_ptr _this() {
      return (::StdMeshers::StdMeshers_LayerDistribution2D_ptr) _do_this(::StdMeshers::StdMeshers_LayerDistribution2D::_PD_repoId);
    }
  };

  class StdMeshers_ProjectionSource1D :
    public virtual StdMeshers::_impl_StdMeshers_ProjectionSource1D,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_ProjectionSource1D();

    inline ::StdMeshers::StdMeshers_ProjectionSource1D_ptr _this() {
      return (::StdMeshers::StdMeshers_ProjectionSource1D_ptr) _do_this(::StdMeshers::StdMeshers_ProjectionSource1D::_PD_repoId);
    }
  };

  class StdMeshers_ProjectionSource2D :
    public virtual StdMeshers::_impl_StdMeshers_ProjectionSource2D,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_ProjectionSource2D();

    inline ::StdMeshers::StdMeshers_ProjectionSource2D_ptr _this() {
      return (::StdMeshers::StdMeshers_ProjectionSource2D_ptr) _do_this(::StdMeshers::StdMeshers_ProjectionSource2D::_PD_repoId);
    }
  };

  class StdMeshers_ProjectionSource3D :
    public virtual StdMeshers::_impl_StdMeshers_ProjectionSource3D,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_ProjectionSource3D();

    inline ::StdMeshers::StdMeshers_ProjectionSource3D_ptr _this() {
      return (::StdMeshers::StdMeshers_ProjectionSource3D_ptr) _do_this(::StdMeshers::StdMeshers_ProjectionSource3D::_PD_repoId);
    }
  };

  class StdMeshers_SegmentLengthAroundVertex :
    public virtual StdMeshers::_impl_StdMeshers_SegmentLengthAroundVertex,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_SegmentLengthAroundVertex();

    inline ::StdMeshers::StdMeshers_SegmentLengthAroundVertex_ptr _this() {
      return (::StdMeshers::StdMeshers_SegmentLengthAroundVertex_ptr) _do_this(::StdMeshers::StdMeshers_SegmentLengthAroundVertex::_PD_repoId);
    }
  };

  class StdMeshers_QuadrangleParams :
    public virtual StdMeshers::_impl_StdMeshers_QuadrangleParams,
    public virtual POA_SMESH::SMESH_Hypothesis
  {
  public:
    virtual ~StdMeshers_QuadrangleParams();

    inline ::StdMeshers::StdMeshers_QuadrangleParams_ptr _this() {
      return (::StdMeshers::StdMeshers_QuadrangleParams_ptr) _do_this(::StdMeshers::StdMeshers_QuadrangleParams::_PD_repoId);
    }
  };

  class StdMeshers_SegmentAroundVertex_0D :
    public virtual StdMeshers::_impl_StdMeshers_SegmentAroundVertex_0D,
    public virtual POA_SMESH::SMESH_0D_Algo
  {
  public:
    virtual ~StdMeshers_SegmentAroundVertex_0D();

    inline ::StdMeshers::StdMeshers_SegmentAroundVertex_0D_ptr _this() {
      return (::StdMeshers::StdMeshers_SegmentAroundVertex_0D_ptr) _do_this(::StdMeshers::StdMeshers_SegmentAroundVertex_0D::_PD_repoId);
    }
  };

  class StdMeshers_Regular_1D :
    public virtual StdMeshers::_impl_StdMeshers_Regular_1D,
    public virtual POA_SMESH::SMESH_1D_Algo
  {
  public:
    virtual ~StdMeshers_Regular_1D();

    inline ::StdMeshers::StdMeshers_Regular_1D_ptr _this() {
      return (::StdMeshers::StdMeshers_Regular_1D_ptr) _do_this(::StdMeshers::StdMeshers_Regular_1D::_PD_repoId);
    }
  };

  class StdMeshers_CompositeSegment_1D :
    public virtual StdMeshers::_impl_StdMeshers_CompositeSegment_1D,
    public virtual POA_SMESH::SMESH_1D_Algo
  {
  public:
    virtual ~StdMeshers_CompositeSegment_1D();

    inline ::StdMeshers::StdMeshers_CompositeSegment_1D_ptr _this() {
      return (::StdMeshers::StdMeshers_CompositeSegment_1D_ptr) _do_this(::StdMeshers::StdMeshers_CompositeSegment_1D::_PD_repoId);
    }
  };

  class StdMeshers_MEFISTO_2D :
    public virtual StdMeshers::_impl_StdMeshers_MEFISTO_2D,
    public virtual POA_SMESH::SMESH_2D_Algo
  {
  public:
    virtual ~StdMeshers_MEFISTO_2D();

    inline ::StdMeshers::StdMeshers_MEFISTO_2D_ptr _this() {
      return (::StdMeshers::StdMeshers_MEFISTO_2D_ptr) _do_this(::StdMeshers::StdMeshers_MEFISTO_2D::_PD_repoId);
    }
  };

  class StdMeshers_Quadrangle_2D :
    public virtual StdMeshers::_impl_StdMeshers_Quadrangle_2D,
    public virtual POA_SMESH::SMESH_2D_Algo
  {
  public:
    virtual ~StdMeshers_Quadrangle_2D();

    inline ::StdMeshers::StdMeshers_Quadrangle_2D_ptr _this() {
      return (::StdMeshers::StdMeshers_Quadrangle_2D_ptr) _do_this(::StdMeshers::StdMeshers_Quadrangle_2D::_PD_repoId);
    }
  };

  class StdMeshers_Hexa_3D :
    public virtual StdMeshers::_impl_StdMeshers_Hexa_3D,
    public virtual POA_SMESH::SMESH_3D_Algo
  {
  public:
    virtual ~StdMeshers_Hexa_3D();

    inline ::StdMeshers::StdMeshers_Hexa_3D_ptr _this() {
      return (::StdMeshers::StdMeshers_Hexa_3D_ptr) _do_this(::StdMeshers::StdMeshers_Hexa_3D::_PD_repoId);
    }
  };

  class StdMeshers_Prism_3D :
    public virtual StdMeshers::_impl_StdMeshers_Prism_3D,
    public virtual POA_SMESH::SMESH_3D_Algo
  {
  public:
    virtual ~StdMeshers_Prism_3D();

    inline ::StdMeshers::StdMeshers_Prism_3D_ptr _this() {
      return (::StdMeshers::StdMeshers_Prism_3D_ptr) _do_this(::StdMeshers::StdMeshers_Prism_3D::_PD_repoId);
    }
  };

  class StdMeshers_RadialPrism_3D :
    public virtual StdMeshers::_impl_StdMeshers_RadialPrism_3D,
    public virtual POA_SMESH::SMESH_3D_Algo
  {
  public:
    virtual ~StdMeshers_RadialPrism_3D();

    inline ::StdMeshers::StdMeshers_RadialPrism_3D_ptr _this() {
      return (::StdMeshers::StdMeshers_RadialPrism_3D_ptr) _do_this(::StdMeshers::StdMeshers_RadialPrism_3D::_PD_repoId);
    }
  };

  class StdMeshers_Projection_3D :
    public virtual StdMeshers::_impl_StdMeshers_Projection_3D,
    public virtual POA_SMESH::SMESH_3D_Algo
  {
  public:
    virtual ~StdMeshers_Projection_3D();

    inline ::StdMeshers::StdMeshers_Projection_3D_ptr _this() {
      return (::StdMeshers::StdMeshers_Projection_3D_ptr) _do_this(::StdMeshers::StdMeshers_Projection_3D::_PD_repoId);
    }
  };

  class StdMeshers_Projection_2D :
    public virtual StdMeshers::_impl_StdMeshers_Projection_2D,
    public virtual POA_SMESH::SMESH_2D_Algo
  {
  public:
    virtual ~StdMeshers_Projection_2D();

    inline ::StdMeshers::StdMeshers_Projection_2D_ptr _this() {
      return (::StdMeshers::StdMeshers_Projection_2D_ptr) _do_this(::StdMeshers::StdMeshers_Projection_2D::_PD_repoId);
    }
  };

  class StdMeshers_Projection_1D :
    public virtual StdMeshers::_impl_StdMeshers_Projection_1D,
    public virtual POA_SMESH::SMESH_1D_Algo
  {
  public:
    virtual ~StdMeshers_Projection_1D();

    inline ::StdMeshers::StdMeshers_Projection_1D_ptr _this() {
      return (::StdMeshers::StdMeshers_Projection_1D_ptr) _do_this(::StdMeshers::StdMeshers_Projection_1D::_PD_repoId);
    }
  };

  class StdMeshers_UseExisting_2D :
    public virtual StdMeshers::_impl_StdMeshers_UseExisting_2D,
    public virtual POA_SMESH::SMESH_2D_Algo
  {
  public:
    virtual ~StdMeshers_UseExisting_2D();

    inline ::StdMeshers::StdMeshers_UseExisting_2D_ptr _this() {
      return (::StdMeshers::StdMeshers_UseExisting_2D_ptr) _do_this(::StdMeshers::StdMeshers_UseExisting_2D::_PD_repoId);
    }
  };

  class StdMeshers_UseExisting_1D :
    public virtual StdMeshers::_impl_StdMeshers_UseExisting_1D,
    public virtual POA_SMESH::SMESH_1D_Algo
  {
  public:
    virtual ~StdMeshers_UseExisting_1D();

    inline ::StdMeshers::StdMeshers_UseExisting_1D_ptr _this() {
      return (::StdMeshers::StdMeshers_UseExisting_1D_ptr) _do_this(::StdMeshers::StdMeshers_UseExisting_1D::_PD_repoId);
    }
  };

  class StdMeshers_RadialQuadrangle_1D2D :
    public virtual StdMeshers::_impl_StdMeshers_RadialQuadrangle_1D2D,
    public virtual POA_SMESH::SMESH_2D_Algo
  {
  public:
    virtual ~StdMeshers_RadialQuadrangle_1D2D();

    inline ::StdMeshers::StdMeshers_RadialQuadrangle_1D2D_ptr _this() {
      return (::StdMeshers::StdMeshers_RadialQuadrangle_1D2D_ptr) _do_this(::StdMeshers::StdMeshers_RadialQuadrangle_1D2D::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_StdMeshers
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



inline void
StdMeshers::StdMeshers_LocalLength::_marshalObjRef(::StdMeshers::StdMeshers_LocalLength_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_MaxLength::_marshalObjRef(::StdMeshers::StdMeshers_MaxLength_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_AutomaticLength::_marshalObjRef(::StdMeshers::StdMeshers_AutomaticLength_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_NumberOfSegments::_marshalObjRef(::StdMeshers::StdMeshers_NumberOfSegments_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_Arithmetic1D::_marshalObjRef(::StdMeshers::StdMeshers_Arithmetic1D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_MaxElementArea::_marshalObjRef(::StdMeshers::StdMeshers_MaxElementArea_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_LengthFromEdges::_marshalObjRef(::StdMeshers::StdMeshers_LengthFromEdges_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_StartEndLength::_marshalObjRef(::StdMeshers::StdMeshers_StartEndLength_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_Deflection1D::_marshalObjRef(::StdMeshers::StdMeshers_Deflection1D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_FixedPoints1D::_marshalObjRef(::StdMeshers::StdMeshers_FixedPoints1D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_MaxElementVolume::_marshalObjRef(::StdMeshers::StdMeshers_MaxElementVolume_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_NotConformAllowed::_marshalObjRef(::StdMeshers::StdMeshers_NotConformAllowed_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_Propagation::_marshalObjRef(::StdMeshers::StdMeshers_Propagation_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_QuadranglePreference::_marshalObjRef(::StdMeshers::StdMeshers_QuadranglePreference_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_TrianglePreference::_marshalObjRef(::StdMeshers::StdMeshers_TrianglePreference_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_QuadraticMesh::_marshalObjRef(::StdMeshers::StdMeshers_QuadraticMesh_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_NumberOfLayers::_marshalObjRef(::StdMeshers::StdMeshers_NumberOfLayers_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_LayerDistribution::_marshalObjRef(::StdMeshers::StdMeshers_LayerDistribution_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_NumberOfLayers2D::_marshalObjRef(::StdMeshers::StdMeshers_NumberOfLayers2D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_LayerDistribution2D::_marshalObjRef(::StdMeshers::StdMeshers_LayerDistribution2D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_ProjectionSource1D::_marshalObjRef(::StdMeshers::StdMeshers_ProjectionSource1D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_ProjectionSource2D::_marshalObjRef(::StdMeshers::StdMeshers_ProjectionSource2D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_ProjectionSource3D::_marshalObjRef(::StdMeshers::StdMeshers_ProjectionSource3D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_SegmentLengthAroundVertex::_marshalObjRef(::StdMeshers::StdMeshers_SegmentLengthAroundVertex_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_QuadrangleParams::_marshalObjRef(::StdMeshers::StdMeshers_QuadrangleParams_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_SegmentAroundVertex_0D::_marshalObjRef(::StdMeshers::StdMeshers_SegmentAroundVertex_0D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_Regular_1D::_marshalObjRef(::StdMeshers::StdMeshers_Regular_1D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_CompositeSegment_1D::_marshalObjRef(::StdMeshers::StdMeshers_CompositeSegment_1D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_MEFISTO_2D::_marshalObjRef(::StdMeshers::StdMeshers_MEFISTO_2D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_Quadrangle_2D::_marshalObjRef(::StdMeshers::StdMeshers_Quadrangle_2D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_Hexa_3D::_marshalObjRef(::StdMeshers::StdMeshers_Hexa_3D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_Prism_3D::_marshalObjRef(::StdMeshers::StdMeshers_Prism_3D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_RadialPrism_3D::_marshalObjRef(::StdMeshers::StdMeshers_RadialPrism_3D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_Projection_3D::_marshalObjRef(::StdMeshers::StdMeshers_Projection_3D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_Projection_2D::_marshalObjRef(::StdMeshers::StdMeshers_Projection_2D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_Projection_1D::_marshalObjRef(::StdMeshers::StdMeshers_Projection_1D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_UseExisting_2D::_marshalObjRef(::StdMeshers::StdMeshers_UseExisting_2D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_UseExisting_1D::_marshalObjRef(::StdMeshers::StdMeshers_UseExisting_1D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
StdMeshers::StdMeshers_RadialQuadrangle_1D2D::_marshalObjRef(::StdMeshers::StdMeshers_RadialQuadrangle_1D2D_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_SMESH__BasicHypothesis
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_SMESH__BasicHypothesis
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_SMESH__BasicHypothesis
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_SMESH__BasicHypothesis
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_SMESH__BasicHypothesis
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_SMESH__BasicHypothesis
#endif

#endif  // __SMESH__BasicHypothesis_hh__

