// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __SMESH__Filter_hh__
#define __SMESH__Filter_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__Filter
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_SMESH__Filter
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_SMESH__Filter
#endif



#ifndef __SALOME__Exception_hh_EXTERNAL_GUARD__
#define __SALOME__Exception_hh_EXTERNAL_GUARD__
#include <SALOME_Exception.hh>
#endif
#ifndef __SALOME__GenericObj_hh_EXTERNAL_GUARD__
#define __SALOME__GenericObj_hh_EXTERNAL_GUARD__
#include <SALOME_GenericObj.hh>
#endif
#ifndef __SALOMEDS_hh_EXTERNAL_GUARD__
#define __SALOMEDS_hh_EXTERNAL_GUARD__
#include <SALOMEDS.hh>
#endif
#ifndef __SALOME__PyNode_hh_EXTERNAL_GUARD__
#define __SALOME__PyNode_hh_EXTERNAL_GUARD__
#include <SALOME_PyNode.hh>
#endif
#ifndef __SALOME__Component_hh_EXTERNAL_GUARD__
#define __SALOME__Component_hh_EXTERNAL_GUARD__
#include <SALOME_Component.hh>
#endif
#ifndef __SALOMEDS__Attributes_hh_EXTERNAL_GUARD__
#define __SALOMEDS__Attributes_hh_EXTERNAL_GUARD__
#include <SALOMEDS_Attributes.hh>
#endif
#ifndef __GEOM__Gen_hh_EXTERNAL_GUARD__
#define __GEOM__Gen_hh_EXTERNAL_GUARD__
#include <GEOM_Gen.hh>
#endif
#ifndef __SALOME__Comm_hh_EXTERNAL_GUARD__
#define __SALOME__Comm_hh_EXTERNAL_GUARD__
#include <SALOME_Comm.hh>
#endif
#ifndef __MED_hh_EXTERNAL_GUARD__
#define __MED_hh_EXTERNAL_GUARD__
#include <MED.hh>
#endif
#ifndef __SMESH__Mesh_hh_EXTERNAL_GUARD__
#define __SMESH__Mesh_hh_EXTERNAL_GUARD__
#include <SMESH_Mesh.hh>
#endif



#ifdef USE_stub_in_nt_dll
# ifndef USE_core_stub_in_nt_dll
#  define USE_core_stub_in_nt_dll
# endif
# ifndef USE_dyn_stub_in_nt_dll
#  define USE_dyn_stub_in_nt_dll
# endif
#endif

#ifdef _core_attr
# error "A local CPP macro _core_attr has already been defined."
#else
# ifdef  USE_core_stub_in_nt_dll
#  define _core_attr _OMNIORB_NTDLL_IMPORT
# else
#  define _core_attr
# endif
#endif

#ifdef _dyn_attr
# error "A local CPP macro _dyn_attr has already been defined."
#else
# ifdef  USE_dyn_stub_in_nt_dll
#  define _dyn_attr _OMNIORB_NTDLL_IMPORT
# else
#  define _dyn_attr
# endif
#endif





_CORBA_MODULE SMESH

_CORBA_MODULE_BEG

  enum FunctorType { FT_AspectRatio, FT_AspectRatio3D, FT_Warping, FT_MinimumAngle, FT_Taper, FT_Skew, FT_Area, FT_Volume3D, FT_FreeBorders, FT_FreeEdges, FT_FreeNodes, FT_FreeFaces, FT_MultiConnection, FT_MultiConnection2D, FT_Length, FT_Length2D, FT_BelongToGeom, FT_BelongToPlane, FT_BelongToCylinder, FT_BelongToGenSurface, FT_LyingOnGeom, FT_RangeOfIds, FT_BadOrientedVolume, FT_LinearOrQuadratic, FT_GroupColor, FT_ElemGeomType, FT_LessThan, FT_MoreThan, FT_EqualTo, FT_LogicalNOT, FT_LogicalAND, FT_LogicalOR, FT_Undefined /*, __max_FunctorType=0xffffffff */ };
  typedef FunctorType& FunctorType_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_FunctorType;

#ifndef __SMESH_mFunctor__
#define __SMESH_mFunctor__

  class Functor;
  class _objref_Functor;
  class _impl_Functor;
  
  typedef _objref_Functor* Functor_ptr;
  typedef Functor_ptr FunctorRef;

  class Functor_Helper {
  public:
    typedef Functor_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_Functor, Functor_Helper> Functor_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Functor,Functor_Helper > Functor_out;

#endif

  // interface Functor
  class Functor {
  public:
    // Declarations for this interface type.
    typedef Functor_ptr _ptr_type;
    typedef Functor_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_Functor :
    public virtual SALOME::_objref_GenericObj
  {
  public:
    void SetMesh(::SMESH::SMESH_Mesh_ptr theMesh);
    FunctorType GetFunctorType();
    ElementType GetElementType();

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

  protected:
    virtual ~_objref_Functor();

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

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

    friend class Functor;
  };

  class _pof_Functor : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Functor() : _OMNI_NS(proxyObjectFactory)(Functor::_PD_repoId) {}
    virtual ~_pof_Functor();

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

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

    virtual void SetMesh(::SMESH::SMESH_Mesh_ptr theMesh) = 0;
    virtual FunctorType GetFunctorType() = 0;
    virtual ElementType GetElementType() = 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_Functor;

#ifndef __SMESH_mNumericalFunctor__
#define __SMESH_mNumericalFunctor__

  class NumericalFunctor;
  class _objref_NumericalFunctor;
  class _impl_NumericalFunctor;
  
  typedef _objref_NumericalFunctor* NumericalFunctor_ptr;
  typedef NumericalFunctor_ptr NumericalFunctorRef;

  class NumericalFunctor_Helper {
  public:
    typedef NumericalFunctor_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_NumericalFunctor, NumericalFunctor_Helper> NumericalFunctor_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_NumericalFunctor,NumericalFunctor_Helper > NumericalFunctor_out;

#endif

  // interface NumericalFunctor
  class NumericalFunctor {
  public:
    // Declarations for this interface type.
    typedef NumericalFunctor_ptr _ptr_type;
    typedef NumericalFunctor_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_NumericalFunctor :
    public virtual _objref_Functor
  {
  public:
    ::CORBA::Double GetValue(::CORBA::Long theElementId);
    void SetPrecision(::CORBA::Long thePrecision);
    ::CORBA::Long GetPrecision();

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

  protected:
    virtual ~_objref_NumericalFunctor();

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

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

    friend class NumericalFunctor;
  };

  class _pof_NumericalFunctor : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_NumericalFunctor() : _OMNI_NS(proxyObjectFactory)(NumericalFunctor::_PD_repoId) {}
    virtual ~_pof_NumericalFunctor();

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

  class _impl_NumericalFunctor :
    public virtual _impl_Functor
  {
  public:
    virtual ~_impl_NumericalFunctor();

    virtual ::CORBA::Double GetValue(::CORBA::Long theElementId) = 0;
    virtual void SetPrecision(::CORBA::Long thePrecision) = 0;
    virtual ::CORBA::Long 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_NumericalFunctor;

#ifndef __SMESH_mMinimumAngle__
#define __SMESH_mMinimumAngle__

  class MinimumAngle;
  class _objref_MinimumAngle;
  class _impl_MinimumAngle;
  
  typedef _objref_MinimumAngle* MinimumAngle_ptr;
  typedef MinimumAngle_ptr MinimumAngleRef;

  class MinimumAngle_Helper {
  public:
    typedef MinimumAngle_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_MinimumAngle, MinimumAngle_Helper> MinimumAngle_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_MinimumAngle,MinimumAngle_Helper > MinimumAngle_out;

#endif

  // interface MinimumAngle
  class MinimumAngle {
  public:
    // Declarations for this interface type.
    typedef MinimumAngle_ptr _ptr_type;
    typedef MinimumAngle_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_MinimumAngle :
    public virtual _objref_NumericalFunctor
  {
  public:
    

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

  protected:
    virtual ~_objref_MinimumAngle();

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

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

    friend class MinimumAngle;
  };

  class _pof_MinimumAngle : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_MinimumAngle() : _OMNI_NS(proxyObjectFactory)(MinimumAngle::_PD_repoId) {}
    virtual ~_pof_MinimumAngle();

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

  class _impl_MinimumAngle :
    public virtual _impl_NumericalFunctor
  {
  public:
    virtual ~_impl_MinimumAngle();

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

#ifndef __SMESH_mAspectRatio__
#define __SMESH_mAspectRatio__

  class AspectRatio;
  class _objref_AspectRatio;
  class _impl_AspectRatio;
  
  typedef _objref_AspectRatio* AspectRatio_ptr;
  typedef AspectRatio_ptr AspectRatioRef;

  class AspectRatio_Helper {
  public:
    typedef AspectRatio_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_AspectRatio, AspectRatio_Helper> AspectRatio_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_AspectRatio,AspectRatio_Helper > AspectRatio_out;

#endif

  // interface AspectRatio
  class AspectRatio {
  public:
    // Declarations for this interface type.
    typedef AspectRatio_ptr _ptr_type;
    typedef AspectRatio_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_AspectRatio :
    public virtual _objref_NumericalFunctor
  {
  public:
    

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

  protected:
    virtual ~_objref_AspectRatio();

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

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

    friend class AspectRatio;
  };

  class _pof_AspectRatio : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_AspectRatio() : _OMNI_NS(proxyObjectFactory)(AspectRatio::_PD_repoId) {}
    virtual ~_pof_AspectRatio();

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

  class _impl_AspectRatio :
    public virtual _impl_NumericalFunctor
  {
  public:
    virtual ~_impl_AspectRatio();

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

#ifndef __SMESH_mAspectRatio3D__
#define __SMESH_mAspectRatio3D__

  class AspectRatio3D;
  class _objref_AspectRatio3D;
  class _impl_AspectRatio3D;
  
  typedef _objref_AspectRatio3D* AspectRatio3D_ptr;
  typedef AspectRatio3D_ptr AspectRatio3DRef;

  class AspectRatio3D_Helper {
  public:
    typedef AspectRatio3D_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_AspectRatio3D, AspectRatio3D_Helper> AspectRatio3D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_AspectRatio3D,AspectRatio3D_Helper > AspectRatio3D_out;

#endif

  // interface AspectRatio3D
  class AspectRatio3D {
  public:
    // Declarations for this interface type.
    typedef AspectRatio3D_ptr _ptr_type;
    typedef AspectRatio3D_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_AspectRatio3D :
    public virtual _objref_NumericalFunctor
  {
  public:
    

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

  protected:
    virtual ~_objref_AspectRatio3D();

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

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

    friend class AspectRatio3D;
  };

  class _pof_AspectRatio3D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_AspectRatio3D() : _OMNI_NS(proxyObjectFactory)(AspectRatio3D::_PD_repoId) {}
    virtual ~_pof_AspectRatio3D();

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

  class _impl_AspectRatio3D :
    public virtual _impl_NumericalFunctor
  {
  public:
    virtual ~_impl_AspectRatio3D();

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

#ifndef __SMESH_mWarping__
#define __SMESH_mWarping__

  class Warping;
  class _objref_Warping;
  class _impl_Warping;
  
  typedef _objref_Warping* Warping_ptr;
  typedef Warping_ptr WarpingRef;

  class Warping_Helper {
  public:
    typedef Warping_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_Warping, Warping_Helper> Warping_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Warping,Warping_Helper > Warping_out;

#endif

  // interface Warping
  class Warping {
  public:
    // Declarations for this interface type.
    typedef Warping_ptr _ptr_type;
    typedef Warping_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_Warping :
    public virtual _objref_NumericalFunctor
  {
  public:
    

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

  protected:
    virtual ~_objref_Warping();

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

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

    friend class Warping;
  };

  class _pof_Warping : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Warping() : _OMNI_NS(proxyObjectFactory)(Warping::_PD_repoId) {}
    virtual ~_pof_Warping();

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

  class _impl_Warping :
    public virtual _impl_NumericalFunctor
  {
  public:
    virtual ~_impl_Warping();

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

#ifndef __SMESH_mTaper__
#define __SMESH_mTaper__

  class Taper;
  class _objref_Taper;
  class _impl_Taper;
  
  typedef _objref_Taper* Taper_ptr;
  typedef Taper_ptr TaperRef;

  class Taper_Helper {
  public:
    typedef Taper_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_Taper, Taper_Helper> Taper_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Taper,Taper_Helper > Taper_out;

#endif

  // interface Taper
  class Taper {
  public:
    // Declarations for this interface type.
    typedef Taper_ptr _ptr_type;
    typedef Taper_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_Taper :
    public virtual _objref_NumericalFunctor
  {
  public:
    

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

  protected:
    virtual ~_objref_Taper();

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

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

    friend class Taper;
  };

  class _pof_Taper : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Taper() : _OMNI_NS(proxyObjectFactory)(Taper::_PD_repoId) {}
    virtual ~_pof_Taper();

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

  class _impl_Taper :
    public virtual _impl_NumericalFunctor
  {
  public:
    virtual ~_impl_Taper();

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

#ifndef __SMESH_mSkew__
#define __SMESH_mSkew__

  class Skew;
  class _objref_Skew;
  class _impl_Skew;
  
  typedef _objref_Skew* Skew_ptr;
  typedef Skew_ptr SkewRef;

  class Skew_Helper {
  public:
    typedef Skew_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_Skew, Skew_Helper> Skew_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Skew,Skew_Helper > Skew_out;

#endif

  // interface Skew
  class Skew {
  public:
    // Declarations for this interface type.
    typedef Skew_ptr _ptr_type;
    typedef Skew_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_Skew :
    public virtual _objref_NumericalFunctor
  {
  public:
    

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

  protected:
    virtual ~_objref_Skew();

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

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

    friend class Skew;
  };

  class _pof_Skew : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Skew() : _OMNI_NS(proxyObjectFactory)(Skew::_PD_repoId) {}
    virtual ~_pof_Skew();

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

  class _impl_Skew :
    public virtual _impl_NumericalFunctor
  {
  public:
    virtual ~_impl_Skew();

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

#ifndef __SMESH_mArea__
#define __SMESH_mArea__

  class Area;
  class _objref_Area;
  class _impl_Area;
  
  typedef _objref_Area* Area_ptr;
  typedef Area_ptr AreaRef;

  class Area_Helper {
  public:
    typedef Area_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_Area, Area_Helper> Area_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Area,Area_Helper > Area_out;

#endif

  // interface Area
  class Area {
  public:
    // Declarations for this interface type.
    typedef Area_ptr _ptr_type;
    typedef Area_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_Area :
    public virtual _objref_NumericalFunctor
  {
  public:
    

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

  protected:
    virtual ~_objref_Area();

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

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

    friend class Area;
  };

  class _pof_Area : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Area() : _OMNI_NS(proxyObjectFactory)(Area::_PD_repoId) {}
    virtual ~_pof_Area();

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

  class _impl_Area :
    public virtual _impl_NumericalFunctor
  {
  public:
    virtual ~_impl_Area();

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

#ifndef __SMESH_mVolume3D__
#define __SMESH_mVolume3D__

  class Volume3D;
  class _objref_Volume3D;
  class _impl_Volume3D;
  
  typedef _objref_Volume3D* Volume3D_ptr;
  typedef Volume3D_ptr Volume3DRef;

  class Volume3D_Helper {
  public:
    typedef Volume3D_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_Volume3D, Volume3D_Helper> Volume3D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Volume3D,Volume3D_Helper > Volume3D_out;

#endif

  // interface Volume3D
  class Volume3D {
  public:
    // Declarations for this interface type.
    typedef Volume3D_ptr _ptr_type;
    typedef Volume3D_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_Volume3D :
    public virtual _objref_NumericalFunctor
  {
  public:
    

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

  protected:
    virtual ~_objref_Volume3D();

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

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

    friend class Volume3D;
  };

  class _pof_Volume3D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Volume3D() : _OMNI_NS(proxyObjectFactory)(Volume3D::_PD_repoId) {}
    virtual ~_pof_Volume3D();

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

  class _impl_Volume3D :
    public virtual _impl_NumericalFunctor
  {
  public:
    virtual ~_impl_Volume3D();

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

#ifndef __SMESH_mLength__
#define __SMESH_mLength__

  class Length;
  class _objref_Length;
  class _impl_Length;
  
  typedef _objref_Length* Length_ptr;
  typedef Length_ptr LengthRef;

  class Length_Helper {
  public:
    typedef Length_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_Length, Length_Helper> Length_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Length,Length_Helper > Length_out;

#endif

  // interface Length
  class Length {
  public:
    // Declarations for this interface type.
    typedef Length_ptr _ptr_type;
    typedef Length_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_Length :
    public virtual _objref_NumericalFunctor
  {
  public:
    

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

  protected:
    virtual ~_objref_Length();

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

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

    friend class Length;
  };

  class _pof_Length : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Length() : _OMNI_NS(proxyObjectFactory)(Length::_PD_repoId) {}
    virtual ~_pof_Length();

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

  class _impl_Length :
    public virtual _impl_NumericalFunctor
  {
  public:
    virtual ~_impl_Length();

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

#ifndef __SMESH_mLength2D__
#define __SMESH_mLength2D__

  class Length2D;
  class _objref_Length2D;
  class _impl_Length2D;
  
  typedef _objref_Length2D* Length2D_ptr;
  typedef Length2D_ptr Length2DRef;

  class Length2D_Helper {
  public:
    typedef Length2D_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_Length2D, Length2D_Helper> Length2D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Length2D,Length2D_Helper > Length2D_out;

#endif

  // interface Length2D
  class Length2D {
  public:
    // Declarations for this interface type.
    typedef Length2D_ptr _ptr_type;
    typedef Length2D_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
    
    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.
    struct Value {
      typedef _CORBA_ConstrType_Fix_Var<Value> _var_type;

      
      ::CORBA::Double myLength;

      ::CORBA::Long myPnt1;

      ::CORBA::Long myPnt2;

    

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

    typedef Value::_var_type Value_var;

    typedef Value& Value_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_Value;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_Values;

    class Values_var;

    class Values : public _CORBA_Unbounded_Sequence< Value >  {
    public:
      typedef Values_var _var_type;
      inline Values() {}
      inline Values(const Values& _s)
        : _CORBA_Unbounded_Sequence< Value > (_s) {}

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

    

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

    class Values_out;

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

    

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

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

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

    

      Values*& _data;

    private:
      Values_out();
      Values_out& operator=(const Values_var&);
    };

  
  };

  class _objref_Length2D :
    public virtual _objref_NumericalFunctor
  {
  public:
    Length2D::Values* GetValues();

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

  protected:
    virtual ~_objref_Length2D();

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

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

    friend class Length2D;
  };

  class _pof_Length2D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Length2D() : _OMNI_NS(proxyObjectFactory)(Length2D::_PD_repoId) {}
    virtual ~_pof_Length2D();

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

  class _impl_Length2D :
    public virtual _impl_NumericalFunctor
  {
  public:
    virtual ~_impl_Length2D();

    virtual Length2D::Values* GetValues() = 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_Length2D;

#ifndef __SMESH_mMultiConnection__
#define __SMESH_mMultiConnection__

  class MultiConnection;
  class _objref_MultiConnection;
  class _impl_MultiConnection;
  
  typedef _objref_MultiConnection* MultiConnection_ptr;
  typedef MultiConnection_ptr MultiConnectionRef;

  class MultiConnection_Helper {
  public:
    typedef MultiConnection_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_MultiConnection, MultiConnection_Helper> MultiConnection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_MultiConnection,MultiConnection_Helper > MultiConnection_out;

#endif

  // interface MultiConnection
  class MultiConnection {
  public:
    // Declarations for this interface type.
    typedef MultiConnection_ptr _ptr_type;
    typedef MultiConnection_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_MultiConnection :
    public virtual _objref_NumericalFunctor
  {
  public:
    

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

  protected:
    virtual ~_objref_MultiConnection();

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

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

    friend class MultiConnection;
  };

  class _pof_MultiConnection : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_MultiConnection() : _OMNI_NS(proxyObjectFactory)(MultiConnection::_PD_repoId) {}
    virtual ~_pof_MultiConnection();

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

  class _impl_MultiConnection :
    public virtual _impl_NumericalFunctor
  {
  public:
    virtual ~_impl_MultiConnection();

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

#ifndef __SMESH_mMultiConnection2D__
#define __SMESH_mMultiConnection2D__

  class MultiConnection2D;
  class _objref_MultiConnection2D;
  class _impl_MultiConnection2D;
  
  typedef _objref_MultiConnection2D* MultiConnection2D_ptr;
  typedef MultiConnection2D_ptr MultiConnection2DRef;

  class MultiConnection2D_Helper {
  public:
    typedef MultiConnection2D_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_MultiConnection2D, MultiConnection2D_Helper> MultiConnection2D_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_MultiConnection2D,MultiConnection2D_Helper > MultiConnection2D_out;

#endif

  // interface MultiConnection2D
  class MultiConnection2D {
  public:
    // Declarations for this interface type.
    typedef MultiConnection2D_ptr _ptr_type;
    typedef MultiConnection2D_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
    
    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.
    struct Value {
      typedef _CORBA_ConstrType_Fix_Var<Value> _var_type;

      
      ::CORBA::Long myNbConnects;

      ::CORBA::Long myPnt1;

      ::CORBA::Long myPnt2;

    

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

    typedef Value::_var_type Value_var;

    typedef Value& Value_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_Value;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_Values;

    class Values_var;

    class Values : public _CORBA_Unbounded_Sequence< Value >  {
    public:
      typedef Values_var _var_type;
      inline Values() {}
      inline Values(const Values& _s)
        : _CORBA_Unbounded_Sequence< Value > (_s) {}

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

    

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

    class Values_out;

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

    

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

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

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

    

      Values*& _data;

    private:
      Values_out();
      Values_out& operator=(const Values_var&);
    };

  
  };

  class _objref_MultiConnection2D :
    public virtual _objref_NumericalFunctor
  {
  public:
    MultiConnection2D::Values* GetValues();

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

  protected:
    virtual ~_objref_MultiConnection2D();

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

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

    friend class MultiConnection2D;
  };

  class _pof_MultiConnection2D : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_MultiConnection2D() : _OMNI_NS(proxyObjectFactory)(MultiConnection2D::_PD_repoId) {}
    virtual ~_pof_MultiConnection2D();

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

  class _impl_MultiConnection2D :
    public virtual _impl_NumericalFunctor
  {
  public:
    virtual ~_impl_MultiConnection2D();

    virtual MultiConnection2D::Values* GetValues() = 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_MultiConnection2D;

#ifndef __SMESH_mPredicate__
#define __SMESH_mPredicate__

  class Predicate;
  class _objref_Predicate;
  class _impl_Predicate;
  
  typedef _objref_Predicate* Predicate_ptr;
  typedef Predicate_ptr PredicateRef;

  class Predicate_Helper {
  public:
    typedef Predicate_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_Predicate, Predicate_Helper> Predicate_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Predicate,Predicate_Helper > Predicate_out;

#endif

  // interface Predicate
  class Predicate {
  public:
    // Declarations for this interface type.
    typedef Predicate_ptr _ptr_type;
    typedef Predicate_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_Predicate :
    public virtual _objref_Functor
  {
  public:
    ::CORBA::Boolean IsSatisfy(::CORBA::Long thEntityId);

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

  protected:
    virtual ~_objref_Predicate();

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

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

    friend class Predicate;
  };

  class _pof_Predicate : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Predicate() : _OMNI_NS(proxyObjectFactory)(Predicate::_PD_repoId) {}
    virtual ~_pof_Predicate();

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

  class _impl_Predicate :
    public virtual _impl_Functor
  {
  public:
    virtual ~_impl_Predicate();

    virtual ::CORBA::Boolean IsSatisfy(::CORBA::Long thEntityId) = 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_Predicate;

#ifndef __SMESH_mBadOrientedVolume__
#define __SMESH_mBadOrientedVolume__

  class BadOrientedVolume;
  class _objref_BadOrientedVolume;
  class _impl_BadOrientedVolume;
  
  typedef _objref_BadOrientedVolume* BadOrientedVolume_ptr;
  typedef BadOrientedVolume_ptr BadOrientedVolumeRef;

  class BadOrientedVolume_Helper {
  public:
    typedef BadOrientedVolume_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_BadOrientedVolume, BadOrientedVolume_Helper> BadOrientedVolume_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_BadOrientedVolume,BadOrientedVolume_Helper > BadOrientedVolume_out;

#endif

  // interface BadOrientedVolume
  class BadOrientedVolume {
  public:
    // Declarations for this interface type.
    typedef BadOrientedVolume_ptr _ptr_type;
    typedef BadOrientedVolume_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_BadOrientedVolume :
    public virtual _objref_Predicate
  {
  public:
    

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

  protected:
    virtual ~_objref_BadOrientedVolume();

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

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

    friend class BadOrientedVolume;
  };

  class _pof_BadOrientedVolume : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_BadOrientedVolume() : _OMNI_NS(proxyObjectFactory)(BadOrientedVolume::_PD_repoId) {}
    virtual ~_pof_BadOrientedVolume();

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

  class _impl_BadOrientedVolume :
    public virtual _impl_Predicate
  {
  public:
    virtual ~_impl_BadOrientedVolume();

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

#ifndef __SMESH_mBelongToGeom__
#define __SMESH_mBelongToGeom__

  class BelongToGeom;
  class _objref_BelongToGeom;
  class _impl_BelongToGeom;
  
  typedef _objref_BelongToGeom* BelongToGeom_ptr;
  typedef BelongToGeom_ptr BelongToGeomRef;

  class BelongToGeom_Helper {
  public:
    typedef BelongToGeom_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_BelongToGeom, BelongToGeom_Helper> BelongToGeom_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_BelongToGeom,BelongToGeom_Helper > BelongToGeom_out;

#endif

  // interface BelongToGeom
  class BelongToGeom {
  public:
    // Declarations for this interface type.
    typedef BelongToGeom_ptr _ptr_type;
    typedef BelongToGeom_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_BelongToGeom :
    public virtual _objref_Predicate
  {
  public:
    void SetGeom(::GEOM::GEOM_Object_ptr theGeom);
    void SetElementType(::SMESH::ElementType theType);
    void SetTolerance(::CORBA::Double theToler);
    ::CORBA::Double GetTolerance();
    void SetShapeName(const char* theName);
    void SetShape(const char* theID, const char* theName);
    char* GetShapeName();
    char* GetShapeID();

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

  protected:
    virtual ~_objref_BelongToGeom();

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

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

    friend class BelongToGeom;
  };

  class _pof_BelongToGeom : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_BelongToGeom() : _OMNI_NS(proxyObjectFactory)(BelongToGeom::_PD_repoId) {}
    virtual ~_pof_BelongToGeom();

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

  class _impl_BelongToGeom :
    public virtual _impl_Predicate
  {
  public:
    virtual ~_impl_BelongToGeom();

    virtual void SetGeom(::GEOM::GEOM_Object_ptr theGeom) = 0;
    virtual void SetElementType(::SMESH::ElementType theType) = 0;
    virtual void SetTolerance(::CORBA::Double theToler) = 0;
    virtual ::CORBA::Double GetTolerance() = 0;
    virtual void SetShapeName(const char* theName) = 0;
    virtual void SetShape(const char* theID, const char* theName) = 0;
    virtual char* GetShapeName() = 0;
    virtual char* GetShapeID() = 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_BelongToGeom;

#ifndef __SMESH_mBelongToSurface__
#define __SMESH_mBelongToSurface__

  class BelongToSurface;
  class _objref_BelongToSurface;
  class _impl_BelongToSurface;
  
  typedef _objref_BelongToSurface* BelongToSurface_ptr;
  typedef BelongToSurface_ptr BelongToSurfaceRef;

  class BelongToSurface_Helper {
  public:
    typedef BelongToSurface_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_BelongToSurface, BelongToSurface_Helper> BelongToSurface_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_BelongToSurface,BelongToSurface_Helper > BelongToSurface_out;

#endif

  // interface BelongToSurface
  class BelongToSurface {
  public:
    // Declarations for this interface type.
    typedef BelongToSurface_ptr _ptr_type;
    typedef BelongToSurface_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_BelongToSurface :
    public virtual _objref_Predicate
  {
  public:
    void SetTolerance(::CORBA::Double theToler);
    ::CORBA::Double GetTolerance();
    void SetShapeName(const char* theName, ::SMESH::ElementType theType);
    void SetShape(const char* theID, const char* theName, ::SMESH::ElementType theType);
    char* GetShapeName();
    char* GetShapeID();
    void SetUseBoundaries(::CORBA::Boolean theUseBndRestrictions);
    ::CORBA::Boolean GetUseBoundaries();

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

  protected:
    virtual ~_objref_BelongToSurface();

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

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

    friend class BelongToSurface;
  };

  class _pof_BelongToSurface : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_BelongToSurface() : _OMNI_NS(proxyObjectFactory)(BelongToSurface::_PD_repoId) {}
    virtual ~_pof_BelongToSurface();

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

  class _impl_BelongToSurface :
    public virtual _impl_Predicate
  {
  public:
    virtual ~_impl_BelongToSurface();

    virtual void SetTolerance(::CORBA::Double theToler) = 0;
    virtual ::CORBA::Double GetTolerance() = 0;
    virtual void SetShapeName(const char* theName, ::SMESH::ElementType theType) = 0;
    virtual void SetShape(const char* theID, const char* theName, ::SMESH::ElementType theType) = 0;
    virtual char* GetShapeName() = 0;
    virtual char* GetShapeID() = 0;
    virtual void SetUseBoundaries(::CORBA::Boolean theUseBndRestrictions) = 0;
    virtual ::CORBA::Boolean GetUseBoundaries() = 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_BelongToSurface;

#ifndef __SMESH_mBelongToPlane__
#define __SMESH_mBelongToPlane__

  class BelongToPlane;
  class _objref_BelongToPlane;
  class _impl_BelongToPlane;
  
  typedef _objref_BelongToPlane* BelongToPlane_ptr;
  typedef BelongToPlane_ptr BelongToPlaneRef;

  class BelongToPlane_Helper {
  public:
    typedef BelongToPlane_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_BelongToPlane, BelongToPlane_Helper> BelongToPlane_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_BelongToPlane,BelongToPlane_Helper > BelongToPlane_out;

#endif

  // interface BelongToPlane
  class BelongToPlane {
  public:
    // Declarations for this interface type.
    typedef BelongToPlane_ptr _ptr_type;
    typedef BelongToPlane_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_BelongToPlane :
    public virtual _objref_BelongToSurface
  {
  public:
    void SetPlane(::GEOM::GEOM_Object_ptr theGeom, ::SMESH::ElementType theType);

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

  protected:
    virtual ~_objref_BelongToPlane();

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

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

    friend class BelongToPlane;
  };

  class _pof_BelongToPlane : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_BelongToPlane() : _OMNI_NS(proxyObjectFactory)(BelongToPlane::_PD_repoId) {}
    virtual ~_pof_BelongToPlane();

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

  class _impl_BelongToPlane :
    public virtual _impl_BelongToSurface
  {
  public:
    virtual ~_impl_BelongToPlane();

    virtual void SetPlane(::GEOM::GEOM_Object_ptr theGeom, ::SMESH::ElementType theType) = 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_BelongToPlane;

#ifndef __SMESH_mBelongToCylinder__
#define __SMESH_mBelongToCylinder__

  class BelongToCylinder;
  class _objref_BelongToCylinder;
  class _impl_BelongToCylinder;
  
  typedef _objref_BelongToCylinder* BelongToCylinder_ptr;
  typedef BelongToCylinder_ptr BelongToCylinderRef;

  class BelongToCylinder_Helper {
  public:
    typedef BelongToCylinder_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_BelongToCylinder, BelongToCylinder_Helper> BelongToCylinder_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_BelongToCylinder,BelongToCylinder_Helper > BelongToCylinder_out;

#endif

  // interface BelongToCylinder
  class BelongToCylinder {
  public:
    // Declarations for this interface type.
    typedef BelongToCylinder_ptr _ptr_type;
    typedef BelongToCylinder_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_BelongToCylinder :
    public virtual _objref_BelongToSurface
  {
  public:
    void SetCylinder(::GEOM::GEOM_Object_ptr theGeom, ::SMESH::ElementType theType);

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

  protected:
    virtual ~_objref_BelongToCylinder();

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

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

    friend class BelongToCylinder;
  };

  class _pof_BelongToCylinder : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_BelongToCylinder() : _OMNI_NS(proxyObjectFactory)(BelongToCylinder::_PD_repoId) {}
    virtual ~_pof_BelongToCylinder();

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

  class _impl_BelongToCylinder :
    public virtual _impl_BelongToSurface
  {
  public:
    virtual ~_impl_BelongToCylinder();

    virtual void SetCylinder(::GEOM::GEOM_Object_ptr theGeom, ::SMESH::ElementType theType) = 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_BelongToCylinder;

#ifndef __SMESH_mBelongToGenSurface__
#define __SMESH_mBelongToGenSurface__

  class BelongToGenSurface;
  class _objref_BelongToGenSurface;
  class _impl_BelongToGenSurface;
  
  typedef _objref_BelongToGenSurface* BelongToGenSurface_ptr;
  typedef BelongToGenSurface_ptr BelongToGenSurfaceRef;

  class BelongToGenSurface_Helper {
  public:
    typedef BelongToGenSurface_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_BelongToGenSurface, BelongToGenSurface_Helper> BelongToGenSurface_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_BelongToGenSurface,BelongToGenSurface_Helper > BelongToGenSurface_out;

#endif

  // interface BelongToGenSurface
  class BelongToGenSurface {
  public:
    // Declarations for this interface type.
    typedef BelongToGenSurface_ptr _ptr_type;
    typedef BelongToGenSurface_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_BelongToGenSurface :
    public virtual _objref_BelongToSurface
  {
  public:
    void SetSurface(::GEOM::GEOM_Object_ptr theGeom, ::SMESH::ElementType theType);

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

  protected:
    virtual ~_objref_BelongToGenSurface();

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

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

    friend class BelongToGenSurface;
  };

  class _pof_BelongToGenSurface : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_BelongToGenSurface() : _OMNI_NS(proxyObjectFactory)(BelongToGenSurface::_PD_repoId) {}
    virtual ~_pof_BelongToGenSurface();

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

  class _impl_BelongToGenSurface :
    public virtual _impl_BelongToSurface
  {
  public:
    virtual ~_impl_BelongToGenSurface();

    virtual void SetSurface(::GEOM::GEOM_Object_ptr theGeom, ::SMESH::ElementType theType) = 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_BelongToGenSurface;

#ifndef __SMESH_mLyingOnGeom__
#define __SMESH_mLyingOnGeom__

  class LyingOnGeom;
  class _objref_LyingOnGeom;
  class _impl_LyingOnGeom;
  
  typedef _objref_LyingOnGeom* LyingOnGeom_ptr;
  typedef LyingOnGeom_ptr LyingOnGeomRef;

  class LyingOnGeom_Helper {
  public:
    typedef LyingOnGeom_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_LyingOnGeom, LyingOnGeom_Helper> LyingOnGeom_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_LyingOnGeom,LyingOnGeom_Helper > LyingOnGeom_out;

#endif

  // interface LyingOnGeom
  class LyingOnGeom {
  public:
    // Declarations for this interface type.
    typedef LyingOnGeom_ptr _ptr_type;
    typedef LyingOnGeom_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_LyingOnGeom :
    public virtual _objref_Predicate
  {
  public:
    void SetGeom(::GEOM::GEOM_Object_ptr theGeom);
    void SetElementType(::SMESH::ElementType theType);
    void SetTolerance(::CORBA::Double theToler);
    ::CORBA::Double GetTolerance();
    void SetShapeName(const char* theName);
    void SetShape(const char* theID, const char* theName);
    char* GetShapeName();
    char* GetShapeID();

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

  protected:
    virtual ~_objref_LyingOnGeom();

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

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

    friend class LyingOnGeom;
  };

  class _pof_LyingOnGeom : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_LyingOnGeom() : _OMNI_NS(proxyObjectFactory)(LyingOnGeom::_PD_repoId) {}
    virtual ~_pof_LyingOnGeom();

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

  class _impl_LyingOnGeom :
    public virtual _impl_Predicate
  {
  public:
    virtual ~_impl_LyingOnGeom();

    virtual void SetGeom(::GEOM::GEOM_Object_ptr theGeom) = 0;
    virtual void SetElementType(::SMESH::ElementType theType) = 0;
    virtual void SetTolerance(::CORBA::Double theToler) = 0;
    virtual ::CORBA::Double GetTolerance() = 0;
    virtual void SetShapeName(const char* theName) = 0;
    virtual void SetShape(const char* theID, const char* theName) = 0;
    virtual char* GetShapeName() = 0;
    virtual char* GetShapeID() = 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_LyingOnGeom;

#ifndef __SMESH_mFreeBorders__
#define __SMESH_mFreeBorders__

  class FreeBorders;
  class _objref_FreeBorders;
  class _impl_FreeBorders;
  
  typedef _objref_FreeBorders* FreeBorders_ptr;
  typedef FreeBorders_ptr FreeBordersRef;

  class FreeBorders_Helper {
  public:
    typedef FreeBorders_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_FreeBorders, FreeBorders_Helper> FreeBorders_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_FreeBorders,FreeBorders_Helper > FreeBorders_out;

#endif

  // interface FreeBorders
  class FreeBorders {
  public:
    // Declarations for this interface type.
    typedef FreeBorders_ptr _ptr_type;
    typedef FreeBorders_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_FreeBorders :
    public virtual _objref_Predicate
  {
  public:
    

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

  protected:
    virtual ~_objref_FreeBorders();

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

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

    friend class FreeBorders;
  };

  class _pof_FreeBorders : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_FreeBorders() : _OMNI_NS(proxyObjectFactory)(FreeBorders::_PD_repoId) {}
    virtual ~_pof_FreeBorders();

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

  class _impl_FreeBorders :
    public virtual _impl_Predicate
  {
  public:
    virtual ~_impl_FreeBorders();

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

#ifndef __SMESH_mFreeEdges__
#define __SMESH_mFreeEdges__

  class FreeEdges;
  class _objref_FreeEdges;
  class _impl_FreeEdges;
  
  typedef _objref_FreeEdges* FreeEdges_ptr;
  typedef FreeEdges_ptr FreeEdgesRef;

  class FreeEdges_Helper {
  public:
    typedef FreeEdges_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_FreeEdges, FreeEdges_Helper> FreeEdges_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_FreeEdges,FreeEdges_Helper > FreeEdges_out;

#endif

  // interface FreeEdges
  class FreeEdges {
  public:
    // Declarations for this interface type.
    typedef FreeEdges_ptr _ptr_type;
    typedef FreeEdges_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
    
    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.
    struct Border {
      typedef _CORBA_ConstrType_Fix_Var<Border> _var_type;

      
      ::CORBA::Long myElemId;

      ::CORBA::Long myPnt1;

      ::CORBA::Long myPnt2;

    

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

    typedef Border::_var_type Border_var;

    typedef Border& Border_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_Border;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_Borders;

    class Borders_var;

    class Borders : public _CORBA_Unbounded_Sequence< Border >  {
    public:
      typedef Borders_var _var_type;
      inline Borders() {}
      inline Borders(const Borders& _s)
        : _CORBA_Unbounded_Sequence< Border > (_s) {}

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

    

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

    class Borders_out;

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

    

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

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

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

    

      Borders*& _data;

    private:
      Borders_out();
      Borders_out& operator=(const Borders_var&);
    };

  
  };

  class _objref_FreeEdges :
    public virtual _objref_Predicate
  {
  public:
    FreeEdges::Borders* GetBorders();

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

  protected:
    virtual ~_objref_FreeEdges();

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

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

    friend class FreeEdges;
  };

  class _pof_FreeEdges : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_FreeEdges() : _OMNI_NS(proxyObjectFactory)(FreeEdges::_PD_repoId) {}
    virtual ~_pof_FreeEdges();

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

  class _impl_FreeEdges :
    public virtual _impl_Predicate
  {
  public:
    virtual ~_impl_FreeEdges();

    virtual FreeEdges::Borders* GetBorders() = 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_FreeEdges;

#ifndef __SMESH_mFreeNodes__
#define __SMESH_mFreeNodes__

  class FreeNodes;
  class _objref_FreeNodes;
  class _impl_FreeNodes;
  
  typedef _objref_FreeNodes* FreeNodes_ptr;
  typedef FreeNodes_ptr FreeNodesRef;

  class FreeNodes_Helper {
  public:
    typedef FreeNodes_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_FreeNodes, FreeNodes_Helper> FreeNodes_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_FreeNodes,FreeNodes_Helper > FreeNodes_out;

#endif

  // interface FreeNodes
  class FreeNodes {
  public:
    // Declarations for this interface type.
    typedef FreeNodes_ptr _ptr_type;
    typedef FreeNodes_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_FreeNodes :
    public virtual _objref_Predicate
  {
  public:
    

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

  protected:
    virtual ~_objref_FreeNodes();

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

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

    friend class FreeNodes;
  };

  class _pof_FreeNodes : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_FreeNodes() : _OMNI_NS(proxyObjectFactory)(FreeNodes::_PD_repoId) {}
    virtual ~_pof_FreeNodes();

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

  class _impl_FreeNodes :
    public virtual _impl_Predicate
  {
  public:
    virtual ~_impl_FreeNodes();

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

#ifndef __SMESH_mFreeFaces__
#define __SMESH_mFreeFaces__

  class FreeFaces;
  class _objref_FreeFaces;
  class _impl_FreeFaces;
  
  typedef _objref_FreeFaces* FreeFaces_ptr;
  typedef FreeFaces_ptr FreeFacesRef;

  class FreeFaces_Helper {
  public:
    typedef FreeFaces_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_FreeFaces, FreeFaces_Helper> FreeFaces_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_FreeFaces,FreeFaces_Helper > FreeFaces_out;

#endif

  // interface FreeFaces
  class FreeFaces {
  public:
    // Declarations for this interface type.
    typedef FreeFaces_ptr _ptr_type;
    typedef FreeFaces_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_FreeFaces :
    public virtual _objref_Predicate
  {
  public:
    

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

  protected:
    virtual ~_objref_FreeFaces();

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

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

    friend class FreeFaces;
  };

  class _pof_FreeFaces : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_FreeFaces() : _OMNI_NS(proxyObjectFactory)(FreeFaces::_PD_repoId) {}
    virtual ~_pof_FreeFaces();

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

  class _impl_FreeFaces :
    public virtual _impl_Predicate
  {
  public:
    virtual ~_impl_FreeFaces();

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

#ifndef __SMESH_mRangeOfIds__
#define __SMESH_mRangeOfIds__

  class RangeOfIds;
  class _objref_RangeOfIds;
  class _impl_RangeOfIds;
  
  typedef _objref_RangeOfIds* RangeOfIds_ptr;
  typedef RangeOfIds_ptr RangeOfIdsRef;

  class RangeOfIds_Helper {
  public:
    typedef RangeOfIds_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_RangeOfIds, RangeOfIds_Helper> RangeOfIds_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_RangeOfIds,RangeOfIds_Helper > RangeOfIds_out;

#endif

  // interface RangeOfIds
  class RangeOfIds {
  public:
    // Declarations for this interface type.
    typedef RangeOfIds_ptr _ptr_type;
    typedef RangeOfIds_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_RangeOfIds :
    public virtual _objref_Predicate
  {
  public:
    void SetRange(const ::SMESH::long_array& theIds);
    ::CORBA::Boolean SetRangeStr(const char* theRange);
    char* GetRangeStr();
    void SetElementType(::SMESH::ElementType theType);

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

  protected:
    virtual ~_objref_RangeOfIds();

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

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

    friend class RangeOfIds;
  };

  class _pof_RangeOfIds : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_RangeOfIds() : _OMNI_NS(proxyObjectFactory)(RangeOfIds::_PD_repoId) {}
    virtual ~_pof_RangeOfIds();

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

  class _impl_RangeOfIds :
    public virtual _impl_Predicate
  {
  public:
    virtual ~_impl_RangeOfIds();

    virtual void SetRange(const ::SMESH::long_array& theIds) = 0;
    virtual ::CORBA::Boolean SetRangeStr(const char* theRange) = 0;
    virtual char* GetRangeStr() = 0;
    virtual void SetElementType(::SMESH::ElementType theType) = 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_RangeOfIds;

#ifndef __SMESH_mComparator__
#define __SMESH_mComparator__

  class Comparator;
  class _objref_Comparator;
  class _impl_Comparator;
  
  typedef _objref_Comparator* Comparator_ptr;
  typedef Comparator_ptr ComparatorRef;

  class Comparator_Helper {
  public:
    typedef Comparator_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_Comparator, Comparator_Helper> Comparator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Comparator,Comparator_Helper > Comparator_out;

#endif

  // interface Comparator
  class Comparator {
  public:
    // Declarations for this interface type.
    typedef Comparator_ptr _ptr_type;
    typedef Comparator_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_Comparator :
    public virtual _objref_Predicate
  {
  public:
    void SetMargin(::CORBA::Double theValue);
    void SetNumFunctor(::SMESH::NumericalFunctor_ptr theFunct);
    ::CORBA::Double GetMargin();

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

  protected:
    virtual ~_objref_Comparator();

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

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

    friend class Comparator;
  };

  class _pof_Comparator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Comparator() : _OMNI_NS(proxyObjectFactory)(Comparator::_PD_repoId) {}
    virtual ~_pof_Comparator();

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

  class _impl_Comparator :
    public virtual _impl_Predicate
  {
  public:
    virtual ~_impl_Comparator();

    virtual void SetMargin(::CORBA::Double theValue) = 0;
    virtual void SetNumFunctor(::SMESH::NumericalFunctor_ptr theFunct) = 0;
    virtual ::CORBA::Double GetMargin() = 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_Comparator;

#ifndef __SMESH_mLessThan__
#define __SMESH_mLessThan__

  class LessThan;
  class _objref_LessThan;
  class _impl_LessThan;
  
  typedef _objref_LessThan* LessThan_ptr;
  typedef LessThan_ptr LessThanRef;

  class LessThan_Helper {
  public:
    typedef LessThan_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_LessThan, LessThan_Helper> LessThan_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_LessThan,LessThan_Helper > LessThan_out;

#endif

  // interface LessThan
  class LessThan {
  public:
    // Declarations for this interface type.
    typedef LessThan_ptr _ptr_type;
    typedef LessThan_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_LessThan :
    public virtual _objref_Comparator
  {
  public:
    

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

  protected:
    virtual ~_objref_LessThan();

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

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

    friend class LessThan;
  };

  class _pof_LessThan : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_LessThan() : _OMNI_NS(proxyObjectFactory)(LessThan::_PD_repoId) {}
    virtual ~_pof_LessThan();

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

  class _impl_LessThan :
    public virtual _impl_Comparator
  {
  public:
    virtual ~_impl_LessThan();

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

#ifndef __SMESH_mMoreThan__
#define __SMESH_mMoreThan__

  class MoreThan;
  class _objref_MoreThan;
  class _impl_MoreThan;
  
  typedef _objref_MoreThan* MoreThan_ptr;
  typedef MoreThan_ptr MoreThanRef;

  class MoreThan_Helper {
  public:
    typedef MoreThan_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_MoreThan, MoreThan_Helper> MoreThan_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_MoreThan,MoreThan_Helper > MoreThan_out;

#endif

  // interface MoreThan
  class MoreThan {
  public:
    // Declarations for this interface type.
    typedef MoreThan_ptr _ptr_type;
    typedef MoreThan_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_MoreThan :
    public virtual _objref_Comparator
  {
  public:
    

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

  protected:
    virtual ~_objref_MoreThan();

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

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

    friend class MoreThan;
  };

  class _pof_MoreThan : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_MoreThan() : _OMNI_NS(proxyObjectFactory)(MoreThan::_PD_repoId) {}
    virtual ~_pof_MoreThan();

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

  class _impl_MoreThan :
    public virtual _impl_Comparator
  {
  public:
    virtual ~_impl_MoreThan();

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

#ifndef __SMESH_mEqualTo__
#define __SMESH_mEqualTo__

  class EqualTo;
  class _objref_EqualTo;
  class _impl_EqualTo;
  
  typedef _objref_EqualTo* EqualTo_ptr;
  typedef EqualTo_ptr EqualToRef;

  class EqualTo_Helper {
  public:
    typedef EqualTo_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_EqualTo, EqualTo_Helper> EqualTo_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_EqualTo,EqualTo_Helper > EqualTo_out;

#endif

  // interface EqualTo
  class EqualTo {
  public:
    // Declarations for this interface type.
    typedef EqualTo_ptr _ptr_type;
    typedef EqualTo_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_EqualTo :
    public virtual _objref_Comparator
  {
  public:
    void SetTolerance(::CORBA::Double theToler);
    ::CORBA::Double GetTolerance();

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

  protected:
    virtual ~_objref_EqualTo();

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

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

    friend class EqualTo;
  };

  class _pof_EqualTo : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_EqualTo() : _OMNI_NS(proxyObjectFactory)(EqualTo::_PD_repoId) {}
    virtual ~_pof_EqualTo();

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

  class _impl_EqualTo :
    public virtual _impl_Comparator
  {
  public:
    virtual ~_impl_EqualTo();

    virtual void SetTolerance(::CORBA::Double theToler) = 0;
    virtual ::CORBA::Double GetTolerance() = 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_EqualTo;

#ifndef __SMESH_mLogical__
#define __SMESH_mLogical__

  class Logical;
  class _objref_Logical;
  class _impl_Logical;
  
  typedef _objref_Logical* Logical_ptr;
  typedef Logical_ptr LogicalRef;

  class Logical_Helper {
  public:
    typedef Logical_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_Logical, Logical_Helper> Logical_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Logical,Logical_Helper > Logical_out;

#endif

  // interface Logical
  class Logical {
  public:
    // Declarations for this interface type.
    typedef Logical_ptr _ptr_type;
    typedef Logical_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_Logical :
    public virtual _objref_Predicate
  {
  public:
    

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

  protected:
    virtual ~_objref_Logical();

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

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

    friend class Logical;
  };

  class _pof_Logical : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Logical() : _OMNI_NS(proxyObjectFactory)(Logical::_PD_repoId) {}
    virtual ~_pof_Logical();

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

  class _impl_Logical :
    public virtual _impl_Predicate
  {
  public:
    virtual ~_impl_Logical();

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

#ifndef __SMESH_mLogicalNOT__
#define __SMESH_mLogicalNOT__

  class LogicalNOT;
  class _objref_LogicalNOT;
  class _impl_LogicalNOT;
  
  typedef _objref_LogicalNOT* LogicalNOT_ptr;
  typedef LogicalNOT_ptr LogicalNOTRef;

  class LogicalNOT_Helper {
  public:
    typedef LogicalNOT_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_LogicalNOT, LogicalNOT_Helper> LogicalNOT_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_LogicalNOT,LogicalNOT_Helper > LogicalNOT_out;

#endif

  // interface LogicalNOT
  class LogicalNOT {
  public:
    // Declarations for this interface type.
    typedef LogicalNOT_ptr _ptr_type;
    typedef LogicalNOT_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_LogicalNOT :
    public virtual _objref_Logical
  {
  public:
    void SetPredicate(::SMESH::Predicate_ptr thePredicate);

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

  protected:
    virtual ~_objref_LogicalNOT();

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

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

    friend class LogicalNOT;
  };

  class _pof_LogicalNOT : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_LogicalNOT() : _OMNI_NS(proxyObjectFactory)(LogicalNOT::_PD_repoId) {}
    virtual ~_pof_LogicalNOT();

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

  class _impl_LogicalNOT :
    public virtual _impl_Logical
  {
  public:
    virtual ~_impl_LogicalNOT();

    virtual void SetPredicate(::SMESH::Predicate_ptr thePredicate) = 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_LogicalNOT;

#ifndef __SMESH_mLogicalBinary__
#define __SMESH_mLogicalBinary__

  class LogicalBinary;
  class _objref_LogicalBinary;
  class _impl_LogicalBinary;
  
  typedef _objref_LogicalBinary* LogicalBinary_ptr;
  typedef LogicalBinary_ptr LogicalBinaryRef;

  class LogicalBinary_Helper {
  public:
    typedef LogicalBinary_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_LogicalBinary, LogicalBinary_Helper> LogicalBinary_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_LogicalBinary,LogicalBinary_Helper > LogicalBinary_out;

#endif

  // interface LogicalBinary
  class LogicalBinary {
  public:
    // Declarations for this interface type.
    typedef LogicalBinary_ptr _ptr_type;
    typedef LogicalBinary_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_LogicalBinary :
    public virtual _objref_Logical
  {
  public:
    void SetPredicate1(::SMESH::Predicate_ptr thePredicate);
    void SetPredicate2(::SMESH::Predicate_ptr thePredicate);

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

  protected:
    virtual ~_objref_LogicalBinary();

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

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

    friend class LogicalBinary;
  };

  class _pof_LogicalBinary : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_LogicalBinary() : _OMNI_NS(proxyObjectFactory)(LogicalBinary::_PD_repoId) {}
    virtual ~_pof_LogicalBinary();

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

  class _impl_LogicalBinary :
    public virtual _impl_Logical
  {
  public:
    virtual ~_impl_LogicalBinary();

    virtual void SetPredicate1(::SMESH::Predicate_ptr thePredicate) = 0;
    virtual void SetPredicate2(::SMESH::Predicate_ptr thePredicate) = 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_LogicalBinary;

#ifndef __SMESH_mLogicalAND__
#define __SMESH_mLogicalAND__

  class LogicalAND;
  class _objref_LogicalAND;
  class _impl_LogicalAND;
  
  typedef _objref_LogicalAND* LogicalAND_ptr;
  typedef LogicalAND_ptr LogicalANDRef;

  class LogicalAND_Helper {
  public:
    typedef LogicalAND_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_LogicalAND, LogicalAND_Helper> LogicalAND_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_LogicalAND,LogicalAND_Helper > LogicalAND_out;

#endif

  // interface LogicalAND
  class LogicalAND {
  public:
    // Declarations for this interface type.
    typedef LogicalAND_ptr _ptr_type;
    typedef LogicalAND_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_LogicalAND :
    public virtual _objref_LogicalBinary
  {
  public:
    

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

  protected:
    virtual ~_objref_LogicalAND();

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

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

    friend class LogicalAND;
  };

  class _pof_LogicalAND : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_LogicalAND() : _OMNI_NS(proxyObjectFactory)(LogicalAND::_PD_repoId) {}
    virtual ~_pof_LogicalAND();

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

  class _impl_LogicalAND :
    public virtual _impl_LogicalBinary
  {
  public:
    virtual ~_impl_LogicalAND();

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

#ifndef __SMESH_mLogicalOR__
#define __SMESH_mLogicalOR__

  class LogicalOR;
  class _objref_LogicalOR;
  class _impl_LogicalOR;
  
  typedef _objref_LogicalOR* LogicalOR_ptr;
  typedef LogicalOR_ptr LogicalORRef;

  class LogicalOR_Helper {
  public:
    typedef LogicalOR_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_LogicalOR, LogicalOR_Helper> LogicalOR_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_LogicalOR,LogicalOR_Helper > LogicalOR_out;

#endif

  // interface LogicalOR
  class LogicalOR {
  public:
    // Declarations for this interface type.
    typedef LogicalOR_ptr _ptr_type;
    typedef LogicalOR_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_LogicalOR :
    public virtual _objref_LogicalBinary
  {
  public:
    

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

  protected:
    virtual ~_objref_LogicalOR();

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

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

    friend class LogicalOR;
  };

  class _pof_LogicalOR : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_LogicalOR() : _OMNI_NS(proxyObjectFactory)(LogicalOR::_PD_repoId) {}
    virtual ~_pof_LogicalOR();

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

  class _impl_LogicalOR :
    public virtual _impl_LogicalBinary
  {
  public:
    virtual ~_impl_LogicalOR();

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

#ifndef __SMESH_mLinearOrQuadratic__
#define __SMESH_mLinearOrQuadratic__

  class LinearOrQuadratic;
  class _objref_LinearOrQuadratic;
  class _impl_LinearOrQuadratic;
  
  typedef _objref_LinearOrQuadratic* LinearOrQuadratic_ptr;
  typedef LinearOrQuadratic_ptr LinearOrQuadraticRef;

  class LinearOrQuadratic_Helper {
  public:
    typedef LinearOrQuadratic_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_LinearOrQuadratic, LinearOrQuadratic_Helper> LinearOrQuadratic_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_LinearOrQuadratic,LinearOrQuadratic_Helper > LinearOrQuadratic_out;

#endif

  // interface LinearOrQuadratic
  class LinearOrQuadratic {
  public:
    // Declarations for this interface type.
    typedef LinearOrQuadratic_ptr _ptr_type;
    typedef LinearOrQuadratic_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_LinearOrQuadratic :
    public virtual _objref_Predicate
  {
  public:
    void SetElementType(::SMESH::ElementType theType);

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

  protected:
    virtual ~_objref_LinearOrQuadratic();

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

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

    friend class LinearOrQuadratic;
  };

  class _pof_LinearOrQuadratic : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_LinearOrQuadratic() : _OMNI_NS(proxyObjectFactory)(LinearOrQuadratic::_PD_repoId) {}
    virtual ~_pof_LinearOrQuadratic();

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

  class _impl_LinearOrQuadratic :
    public virtual _impl_Predicate
  {
  public:
    virtual ~_impl_LinearOrQuadratic();

    virtual void SetElementType(::SMESH::ElementType theType) = 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_LinearOrQuadratic;

#ifndef __SMESH_mGroupColor__
#define __SMESH_mGroupColor__

  class GroupColor;
  class _objref_GroupColor;
  class _impl_GroupColor;
  
  typedef _objref_GroupColor* GroupColor_ptr;
  typedef GroupColor_ptr GroupColorRef;

  class GroupColor_Helper {
  public:
    typedef GroupColor_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_GroupColor, GroupColor_Helper> GroupColor_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_GroupColor,GroupColor_Helper > GroupColor_out;

#endif

  // interface GroupColor
  class GroupColor {
  public:
    // Declarations for this interface type.
    typedef GroupColor_ptr _ptr_type;
    typedef GroupColor_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_GroupColor :
    public virtual _objref_Predicate
  {
  public:
    void SetElementType(::SMESH::ElementType theType);
    void SetColorStr(const char* theColor);
    char* GetColorStr();

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

  protected:
    virtual ~_objref_GroupColor();

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

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

    friend class GroupColor;
  };

  class _pof_GroupColor : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_GroupColor() : _OMNI_NS(proxyObjectFactory)(GroupColor::_PD_repoId) {}
    virtual ~_pof_GroupColor();

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

  class _impl_GroupColor :
    public virtual _impl_Predicate
  {
  public:
    virtual ~_impl_GroupColor();

    virtual void SetElementType(::SMESH::ElementType theType) = 0;
    virtual void SetColorStr(const char* theColor) = 0;
    virtual char* GetColorStr() = 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_GroupColor;

#ifndef __SMESH_mElemGeomType__
#define __SMESH_mElemGeomType__

  class ElemGeomType;
  class _objref_ElemGeomType;
  class _impl_ElemGeomType;
  
  typedef _objref_ElemGeomType* ElemGeomType_ptr;
  typedef ElemGeomType_ptr ElemGeomTypeRef;

  class ElemGeomType_Helper {
  public:
    typedef ElemGeomType_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_ElemGeomType, ElemGeomType_Helper> ElemGeomType_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_ElemGeomType,ElemGeomType_Helper > ElemGeomType_out;

#endif

  // interface ElemGeomType
  class ElemGeomType {
  public:
    // Declarations for this interface type.
    typedef ElemGeomType_ptr _ptr_type;
    typedef ElemGeomType_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_ElemGeomType :
    public virtual _objref_Predicate
  {
  public:
    void SetElementType(::SMESH::ElementType theType);
    void SetGeometryType(::SMESH::GeometryType theType);

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

  protected:
    virtual ~_objref_ElemGeomType();

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

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

    friend class ElemGeomType;
  };

  class _pof_ElemGeomType : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_ElemGeomType() : _OMNI_NS(proxyObjectFactory)(ElemGeomType::_PD_repoId) {}
    virtual ~_pof_ElemGeomType();

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

  class _impl_ElemGeomType :
    public virtual _impl_Predicate
  {
  public:
    virtual ~_impl_ElemGeomType();

    virtual void SetElementType(::SMESH::ElementType theType) = 0;
    virtual void SetGeometryType(::SMESH::GeometryType theType) = 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_ElemGeomType;

#ifndef __SMESH_mFilter__
#define __SMESH_mFilter__

  class Filter;
  class _objref_Filter;
  class _impl_Filter;
  
  typedef _objref_Filter* Filter_ptr;
  typedef Filter_ptr FilterRef;

  class Filter_Helper {
  public:
    typedef Filter_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_Filter, Filter_Helper> Filter_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Filter,Filter_Helper > Filter_out;

#endif

  // interface Filter
  class Filter {
  public:
    // Declarations for this interface type.
    typedef Filter_ptr _ptr_type;
    typedef Filter_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
    
    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.
    struct Criterion {
      typedef _CORBA_ConstrType_Variable_Var<Criterion> _var_type;

      
      ::CORBA::Long Type;

      ::CORBA::Long Compare;

      ::CORBA::Double Threshold;

      ::CORBA::String_member ThresholdStr;

      ::CORBA::String_member ThresholdID;

      ::CORBA::Long UnaryOp;

      ::CORBA::Long BinaryOp;

      ::CORBA::Double Tolerance;

      ElementType TypeOfElement;

      ::CORBA::Long Precision;

    

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

    typedef Criterion::_var_type Criterion_var;

    typedef _CORBA_ConstrType_Variable_OUT_arg< Criterion,Criterion_var > Criterion_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_Criterion;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_Criteria;

    class Criteria_var;

    class Criteria : public _CORBA_Unbounded_Sequence< Criterion >  {
    public:
      typedef Criteria_var _var_type;
      inline Criteria() {}
      inline Criteria(const Criteria& _s)
        : _CORBA_Unbounded_Sequence< Criterion > (_s) {}

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

    

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

    class Criteria_out;

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

    

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

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

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

    

      Criteria*& _data;

    private:
      Criteria_out();
      Criteria_out& operator=(const Criteria_var&);
    };

  
  };

  class _objref_Filter :
    public virtual SALOME::_objref_GenericObj,
    public virtual _objref_SMESH_IDSource
  {
  public:
    void SetPredicate(::SMESH::Predicate_ptr thePredicate);
    void SetMesh(::SMESH::SMESH_Mesh_ptr theMesh);
    long_array* GetElementsId(::SMESH::SMESH_Mesh_ptr theMesh);
    ElementType GetElementType();
    Predicate_ptr GetPredicate();
    ::CORBA::Boolean GetCriteria(::SMESH::Filter::Criteria_out theCriteria);
    ::CORBA::Boolean SetCriteria(const ::SMESH::Filter::Criteria& theCriteria);

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

  protected:
    virtual ~_objref_Filter();

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

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

    friend class Filter;
  };

  class _pof_Filter : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Filter() : _OMNI_NS(proxyObjectFactory)(Filter::_PD_repoId) {}
    virtual ~_pof_Filter();

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

  class _impl_Filter :
    public virtual SALOME::_impl_GenericObj,
    public virtual _impl_SMESH_IDSource
  {
  public:
    virtual ~_impl_Filter();

    virtual void SetPredicate(::SMESH::Predicate_ptr thePredicate) = 0;
    virtual void SetMesh(::SMESH::SMESH_Mesh_ptr theMesh) = 0;
    virtual long_array* GetElementsId(::SMESH::SMESH_Mesh_ptr theMesh) = 0;
    virtual ElementType GetElementType() = 0;
    virtual Predicate_ptr GetPredicate() = 0;
    virtual ::CORBA::Boolean GetCriteria(::SMESH::Filter::Criteria_out theCriteria) = 0;
    virtual ::CORBA::Boolean SetCriteria(const ::SMESH::Filter::Criteria& theCriteria) = 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_Filter;

#ifndef __SMESH_mFilterLibrary__
#define __SMESH_mFilterLibrary__

  class FilterLibrary;
  class _objref_FilterLibrary;
  class _impl_FilterLibrary;
  
  typedef _objref_FilterLibrary* FilterLibrary_ptr;
  typedef FilterLibrary_ptr FilterLibraryRef;

  class FilterLibrary_Helper {
  public:
    typedef FilterLibrary_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_FilterLibrary, FilterLibrary_Helper> FilterLibrary_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_FilterLibrary,FilterLibrary_Helper > FilterLibrary_out;

#endif

  // interface FilterLibrary
  class FilterLibrary {
  public:
    // Declarations for this interface type.
    typedef FilterLibrary_ptr _ptr_type;
    typedef FilterLibrary_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_FilterLibrary :
    public virtual SALOME::_objref_GenericObj
  {
  public:
    Filter_ptr Copy(const char* theFilterName);
    ::CORBA::Boolean Add(const char* theFilterName, ::SMESH::Filter_ptr theFilter);
    ::CORBA::Boolean AddEmpty(const char* theFilterName, ::SMESH::ElementType theType);
    ::CORBA::Boolean Delete(const char* theFilterName);
    ::CORBA::Boolean Replace(const char* theFilterName, const char* theNewName, ::SMESH::Filter_ptr theFilter);
    ::CORBA::Boolean Save();
    ::CORBA::Boolean SaveAs(const char* aFileName);
    ::CORBA::Boolean IsPresent(const char* aFilterName);
    ::CORBA::Long NbFilters(::SMESH::ElementType aType);
    string_array* GetNames(::SMESH::ElementType aType);
    string_array* GetAllNames();
    void SetFileName(const char* aFilterName);
    char* GetFileName();

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

  protected:
    virtual ~_objref_FilterLibrary();

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

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

    friend class FilterLibrary;
  };

  class _pof_FilterLibrary : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_FilterLibrary() : _OMNI_NS(proxyObjectFactory)(FilterLibrary::_PD_repoId) {}
    virtual ~_pof_FilterLibrary();

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

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

    virtual Filter_ptr Copy(const char* theFilterName) = 0;
    virtual ::CORBA::Boolean Add(const char* theFilterName, ::SMESH::Filter_ptr theFilter) = 0;
    virtual ::CORBA::Boolean AddEmpty(const char* theFilterName, ::SMESH::ElementType theType) = 0;
    virtual ::CORBA::Boolean Delete(const char* theFilterName) = 0;
    virtual ::CORBA::Boolean Replace(const char* theFilterName, const char* theNewName, ::SMESH::Filter_ptr theFilter) = 0;
    virtual ::CORBA::Boolean Save() = 0;
    virtual ::CORBA::Boolean SaveAs(const char* aFileName) = 0;
    virtual ::CORBA::Boolean IsPresent(const char* aFilterName) = 0;
    virtual ::CORBA::Long NbFilters(::SMESH::ElementType aType) = 0;
    virtual string_array* GetNames(::SMESH::ElementType aType) = 0;
    virtual string_array* GetAllNames() = 0;
    virtual void SetFileName(const char* aFilterName) = 0;
    virtual char* GetFileName() = 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_FilterLibrary;

#ifndef __SMESH_mFilterManager__
#define __SMESH_mFilterManager__

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

  class FilterManager_Helper {
  public:
    typedef FilterManager_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_FilterManager, FilterManager_Helper> FilterManager_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_FilterManager,FilterManager_Helper > FilterManager_out;

#endif

  // interface FilterManager
  class FilterManager {
  public:
    // Declarations for this interface type.
    typedef FilterManager_ptr _ptr_type;
    typedef FilterManager_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_FilterManager :
    public virtual SALOME::_objref_GenericObj
  {
  public:
    MinimumAngle_ptr CreateMinimumAngle();
    AspectRatio_ptr CreateAspectRatio();
    AspectRatio3D_ptr CreateAspectRatio3D();
    Warping_ptr CreateWarping();
    Taper_ptr CreateTaper();
    Skew_ptr CreateSkew();
    Area_ptr CreateArea();
    Volume3D_ptr CreateVolume3D();
    Length_ptr CreateLength();
    Length2D_ptr CreateLength2D();
    MultiConnection_ptr CreateMultiConnection();
    MultiConnection2D_ptr CreateMultiConnection2D();
    BelongToGeom_ptr CreateBelongToGeom();
    BelongToPlane_ptr CreateBelongToPlane();
    BelongToCylinder_ptr CreateBelongToCylinder();
    BelongToGenSurface_ptr CreateBelongToGenSurface();
    LyingOnGeom_ptr CreateLyingOnGeom();
    FreeBorders_ptr CreateFreeBorders();
    FreeEdges_ptr CreateFreeEdges();
    FreeNodes_ptr CreateFreeNodes();
    FreeFaces_ptr CreateFreeFaces();
    RangeOfIds_ptr CreateRangeOfIds();
    BadOrientedVolume_ptr CreateBadOrientedVolume();
    LinearOrQuadratic_ptr CreateLinearOrQuadratic();
    GroupColor_ptr CreateGroupColor();
    ElemGeomType_ptr CreateElemGeomType();
    LessThan_ptr CreateLessThan();
    MoreThan_ptr CreateMoreThan();
    EqualTo_ptr CreateEqualTo();
    LogicalNOT_ptr CreateLogicalNOT();
    LogicalAND_ptr CreateLogicalAND();
    LogicalOR_ptr CreateLogicalOR();
    Filter_ptr CreateFilter();
    FilterLibrary_ptr LoadLibrary(const char* aFileName);
    FilterLibrary_ptr CreateLibrary();
    ::CORBA::Boolean DeleteLibrary(const char* aFileName);

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

  protected:
    virtual ~_objref_FilterManager();

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

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

    friend class FilterManager;
  };

  class _pof_FilterManager : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_FilterManager() : _OMNI_NS(proxyObjectFactory)(FilterManager::_PD_repoId) {}
    virtual ~_pof_FilterManager();

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

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

    virtual MinimumAngle_ptr CreateMinimumAngle() = 0;
    virtual AspectRatio_ptr CreateAspectRatio() = 0;
    virtual AspectRatio3D_ptr CreateAspectRatio3D() = 0;
    virtual Warping_ptr CreateWarping() = 0;
    virtual Taper_ptr CreateTaper() = 0;
    virtual Skew_ptr CreateSkew() = 0;
    virtual Area_ptr CreateArea() = 0;
    virtual Volume3D_ptr CreateVolume3D() = 0;
    virtual Length_ptr CreateLength() = 0;
    virtual Length2D_ptr CreateLength2D() = 0;
    virtual MultiConnection_ptr CreateMultiConnection() = 0;
    virtual MultiConnection2D_ptr CreateMultiConnection2D() = 0;
    virtual BelongToGeom_ptr CreateBelongToGeom() = 0;
    virtual BelongToPlane_ptr CreateBelongToPlane() = 0;
    virtual BelongToCylinder_ptr CreateBelongToCylinder() = 0;
    virtual BelongToGenSurface_ptr CreateBelongToGenSurface() = 0;
    virtual LyingOnGeom_ptr CreateLyingOnGeom() = 0;
    virtual FreeBorders_ptr CreateFreeBorders() = 0;
    virtual FreeEdges_ptr CreateFreeEdges() = 0;
    virtual FreeNodes_ptr CreateFreeNodes() = 0;
    virtual FreeFaces_ptr CreateFreeFaces() = 0;
    virtual RangeOfIds_ptr CreateRangeOfIds() = 0;
    virtual BadOrientedVolume_ptr CreateBadOrientedVolume() = 0;
    virtual LinearOrQuadratic_ptr CreateLinearOrQuadratic() = 0;
    virtual GroupColor_ptr CreateGroupColor() = 0;
    virtual ElemGeomType_ptr CreateElemGeomType() = 0;
    virtual LessThan_ptr CreateLessThan() = 0;
    virtual MoreThan_ptr CreateMoreThan() = 0;
    virtual EqualTo_ptr CreateEqualTo() = 0;
    virtual LogicalNOT_ptr CreateLogicalNOT() = 0;
    virtual LogicalAND_ptr CreateLogicalAND() = 0;
    virtual LogicalOR_ptr CreateLogicalOR() = 0;
    virtual Filter_ptr CreateFilter() = 0;
    virtual FilterLibrary_ptr LoadLibrary(const char* aFileName) = 0;
    virtual FilterLibrary_ptr CreateLibrary() = 0;
    virtual ::CORBA::Boolean DeleteLibrary(const char* aFileName) = 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_FilterManager;

_CORBA_MODULE_END



_CORBA_MODULE POA_SMESH
_CORBA_MODULE_BEG

  class Functor :
    public virtual SMESH::_impl_Functor,
    public virtual POA_SALOME::GenericObj
  {
  public:
    virtual ~Functor();

    inline ::SMESH::Functor_ptr _this() {
      return (::SMESH::Functor_ptr) _do_this(::SMESH::Functor::_PD_repoId);
    }
  };

  class NumericalFunctor :
    public virtual SMESH::_impl_NumericalFunctor,
    public virtual Functor
  {
  public:
    virtual ~NumericalFunctor();

    inline ::SMESH::NumericalFunctor_ptr _this() {
      return (::SMESH::NumericalFunctor_ptr) _do_this(::SMESH::NumericalFunctor::_PD_repoId);
    }
  };

  class MinimumAngle :
    public virtual SMESH::_impl_MinimumAngle,
    public virtual NumericalFunctor
  {
  public:
    virtual ~MinimumAngle();

    inline ::SMESH::MinimumAngle_ptr _this() {
      return (::SMESH::MinimumAngle_ptr) _do_this(::SMESH::MinimumAngle::_PD_repoId);
    }
  };

  class AspectRatio :
    public virtual SMESH::_impl_AspectRatio,
    public virtual NumericalFunctor
  {
  public:
    virtual ~AspectRatio();

    inline ::SMESH::AspectRatio_ptr _this() {
      return (::SMESH::AspectRatio_ptr) _do_this(::SMESH::AspectRatio::_PD_repoId);
    }
  };

  class AspectRatio3D :
    public virtual SMESH::_impl_AspectRatio3D,
    public virtual NumericalFunctor
  {
  public:
    virtual ~AspectRatio3D();

    inline ::SMESH::AspectRatio3D_ptr _this() {
      return (::SMESH::AspectRatio3D_ptr) _do_this(::SMESH::AspectRatio3D::_PD_repoId);
    }
  };

  class Warping :
    public virtual SMESH::_impl_Warping,
    public virtual NumericalFunctor
  {
  public:
    virtual ~Warping();

    inline ::SMESH::Warping_ptr _this() {
      return (::SMESH::Warping_ptr) _do_this(::SMESH::Warping::_PD_repoId);
    }
  };

  class Taper :
    public virtual SMESH::_impl_Taper,
    public virtual NumericalFunctor
  {
  public:
    virtual ~Taper();

    inline ::SMESH::Taper_ptr _this() {
      return (::SMESH::Taper_ptr) _do_this(::SMESH::Taper::_PD_repoId);
    }
  };

  class Skew :
    public virtual SMESH::_impl_Skew,
    public virtual NumericalFunctor
  {
  public:
    virtual ~Skew();

    inline ::SMESH::Skew_ptr _this() {
      return (::SMESH::Skew_ptr) _do_this(::SMESH::Skew::_PD_repoId);
    }
  };

  class Area :
    public virtual SMESH::_impl_Area,
    public virtual NumericalFunctor
  {
  public:
    virtual ~Area();

    inline ::SMESH::Area_ptr _this() {
      return (::SMESH::Area_ptr) _do_this(::SMESH::Area::_PD_repoId);
    }
  };

  class Volume3D :
    public virtual SMESH::_impl_Volume3D,
    public virtual NumericalFunctor
  {
  public:
    virtual ~Volume3D();

    inline ::SMESH::Volume3D_ptr _this() {
      return (::SMESH::Volume3D_ptr) _do_this(::SMESH::Volume3D::_PD_repoId);
    }
  };

  class Length :
    public virtual SMESH::_impl_Length,
    public virtual NumericalFunctor
  {
  public:
    virtual ~Length();

    inline ::SMESH::Length_ptr _this() {
      return (::SMESH::Length_ptr) _do_this(::SMESH::Length::_PD_repoId);
    }
  };

  class Length2D :
    public virtual SMESH::_impl_Length2D,
    public virtual NumericalFunctor
  {
  public:
    virtual ~Length2D();

    inline ::SMESH::Length2D_ptr _this() {
      return (::SMESH::Length2D_ptr) _do_this(::SMESH::Length2D::_PD_repoId);
    }
  };

  class MultiConnection :
    public virtual SMESH::_impl_MultiConnection,
    public virtual NumericalFunctor
  {
  public:
    virtual ~MultiConnection();

    inline ::SMESH::MultiConnection_ptr _this() {
      return (::SMESH::MultiConnection_ptr) _do_this(::SMESH::MultiConnection::_PD_repoId);
    }
  };

  class MultiConnection2D :
    public virtual SMESH::_impl_MultiConnection2D,
    public virtual NumericalFunctor
  {
  public:
    virtual ~MultiConnection2D();

    inline ::SMESH::MultiConnection2D_ptr _this() {
      return (::SMESH::MultiConnection2D_ptr) _do_this(::SMESH::MultiConnection2D::_PD_repoId);
    }
  };

  class Predicate :
    public virtual SMESH::_impl_Predicate,
    public virtual Functor
  {
  public:
    virtual ~Predicate();

    inline ::SMESH::Predicate_ptr _this() {
      return (::SMESH::Predicate_ptr) _do_this(::SMESH::Predicate::_PD_repoId);
    }
  };

  class BadOrientedVolume :
    public virtual SMESH::_impl_BadOrientedVolume,
    public virtual Predicate
  {
  public:
    virtual ~BadOrientedVolume();

    inline ::SMESH::BadOrientedVolume_ptr _this() {
      return (::SMESH::BadOrientedVolume_ptr) _do_this(::SMESH::BadOrientedVolume::_PD_repoId);
    }
  };

  class BelongToGeom :
    public virtual SMESH::_impl_BelongToGeom,
    public virtual Predicate
  {
  public:
    virtual ~BelongToGeom();

    inline ::SMESH::BelongToGeom_ptr _this() {
      return (::SMESH::BelongToGeom_ptr) _do_this(::SMESH::BelongToGeom::_PD_repoId);
    }
  };

  class BelongToSurface :
    public virtual SMESH::_impl_BelongToSurface,
    public virtual Predicate
  {
  public:
    virtual ~BelongToSurface();

    inline ::SMESH::BelongToSurface_ptr _this() {
      return (::SMESH::BelongToSurface_ptr) _do_this(::SMESH::BelongToSurface::_PD_repoId);
    }
  };

  class BelongToPlane :
    public virtual SMESH::_impl_BelongToPlane,
    public virtual BelongToSurface
  {
  public:
    virtual ~BelongToPlane();

    inline ::SMESH::BelongToPlane_ptr _this() {
      return (::SMESH::BelongToPlane_ptr) _do_this(::SMESH::BelongToPlane::_PD_repoId);
    }
  };

  class BelongToCylinder :
    public virtual SMESH::_impl_BelongToCylinder,
    public virtual BelongToSurface
  {
  public:
    virtual ~BelongToCylinder();

    inline ::SMESH::BelongToCylinder_ptr _this() {
      return (::SMESH::BelongToCylinder_ptr) _do_this(::SMESH::BelongToCylinder::_PD_repoId);
    }
  };

  class BelongToGenSurface :
    public virtual SMESH::_impl_BelongToGenSurface,
    public virtual BelongToSurface
  {
  public:
    virtual ~BelongToGenSurface();

    inline ::SMESH::BelongToGenSurface_ptr _this() {
      return (::SMESH::BelongToGenSurface_ptr) _do_this(::SMESH::BelongToGenSurface::_PD_repoId);
    }
  };

  class LyingOnGeom :
    public virtual SMESH::_impl_LyingOnGeom,
    public virtual Predicate
  {
  public:
    virtual ~LyingOnGeom();

    inline ::SMESH::LyingOnGeom_ptr _this() {
      return (::SMESH::LyingOnGeom_ptr) _do_this(::SMESH::LyingOnGeom::_PD_repoId);
    }
  };

  class FreeBorders :
    public virtual SMESH::_impl_FreeBorders,
    public virtual Predicate
  {
  public:
    virtual ~FreeBorders();

    inline ::SMESH::FreeBorders_ptr _this() {
      return (::SMESH::FreeBorders_ptr) _do_this(::SMESH::FreeBorders::_PD_repoId);
    }
  };

  class FreeEdges :
    public virtual SMESH::_impl_FreeEdges,
    public virtual Predicate
  {
  public:
    virtual ~FreeEdges();

    inline ::SMESH::FreeEdges_ptr _this() {
      return (::SMESH::FreeEdges_ptr) _do_this(::SMESH::FreeEdges::_PD_repoId);
    }
  };

  class FreeNodes :
    public virtual SMESH::_impl_FreeNodes,
    public virtual Predicate
  {
  public:
    virtual ~FreeNodes();

    inline ::SMESH::FreeNodes_ptr _this() {
      return (::SMESH::FreeNodes_ptr) _do_this(::SMESH::FreeNodes::_PD_repoId);
    }
  };

  class FreeFaces :
    public virtual SMESH::_impl_FreeFaces,
    public virtual Predicate
  {
  public:
    virtual ~FreeFaces();

    inline ::SMESH::FreeFaces_ptr _this() {
      return (::SMESH::FreeFaces_ptr) _do_this(::SMESH::FreeFaces::_PD_repoId);
    }
  };

  class RangeOfIds :
    public virtual SMESH::_impl_RangeOfIds,
    public virtual Predicate
  {
  public:
    virtual ~RangeOfIds();

    inline ::SMESH::RangeOfIds_ptr _this() {
      return (::SMESH::RangeOfIds_ptr) _do_this(::SMESH::RangeOfIds::_PD_repoId);
    }
  };

  class Comparator :
    public virtual SMESH::_impl_Comparator,
    public virtual Predicate
  {
  public:
    virtual ~Comparator();

    inline ::SMESH::Comparator_ptr _this() {
      return (::SMESH::Comparator_ptr) _do_this(::SMESH::Comparator::_PD_repoId);
    }
  };

  class LessThan :
    public virtual SMESH::_impl_LessThan,
    public virtual Comparator
  {
  public:
    virtual ~LessThan();

    inline ::SMESH::LessThan_ptr _this() {
      return (::SMESH::LessThan_ptr) _do_this(::SMESH::LessThan::_PD_repoId);
    }
  };

  class MoreThan :
    public virtual SMESH::_impl_MoreThan,
    public virtual Comparator
  {
  public:
    virtual ~MoreThan();

    inline ::SMESH::MoreThan_ptr _this() {
      return (::SMESH::MoreThan_ptr) _do_this(::SMESH::MoreThan::_PD_repoId);
    }
  };

  class EqualTo :
    public virtual SMESH::_impl_EqualTo,
    public virtual Comparator
  {
  public:
    virtual ~EqualTo();

    inline ::SMESH::EqualTo_ptr _this() {
      return (::SMESH::EqualTo_ptr) _do_this(::SMESH::EqualTo::_PD_repoId);
    }
  };

  class Logical :
    public virtual SMESH::_impl_Logical,
    public virtual Predicate
  {
  public:
    virtual ~Logical();

    inline ::SMESH::Logical_ptr _this() {
      return (::SMESH::Logical_ptr) _do_this(::SMESH::Logical::_PD_repoId);
    }
  };

  class LogicalNOT :
    public virtual SMESH::_impl_LogicalNOT,
    public virtual Logical
  {
  public:
    virtual ~LogicalNOT();

    inline ::SMESH::LogicalNOT_ptr _this() {
      return (::SMESH::LogicalNOT_ptr) _do_this(::SMESH::LogicalNOT::_PD_repoId);
    }
  };

  class LogicalBinary :
    public virtual SMESH::_impl_LogicalBinary,
    public virtual Logical
  {
  public:
    virtual ~LogicalBinary();

    inline ::SMESH::LogicalBinary_ptr _this() {
      return (::SMESH::LogicalBinary_ptr) _do_this(::SMESH::LogicalBinary::_PD_repoId);
    }
  };

  class LogicalAND :
    public virtual SMESH::_impl_LogicalAND,
    public virtual LogicalBinary
  {
  public:
    virtual ~LogicalAND();

    inline ::SMESH::LogicalAND_ptr _this() {
      return (::SMESH::LogicalAND_ptr) _do_this(::SMESH::LogicalAND::_PD_repoId);
    }
  };

  class LogicalOR :
    public virtual SMESH::_impl_LogicalOR,
    public virtual LogicalBinary
  {
  public:
    virtual ~LogicalOR();

    inline ::SMESH::LogicalOR_ptr _this() {
      return (::SMESH::LogicalOR_ptr) _do_this(::SMESH::LogicalOR::_PD_repoId);
    }
  };

  class LinearOrQuadratic :
    public virtual SMESH::_impl_LinearOrQuadratic,
    public virtual Predicate
  {
  public:
    virtual ~LinearOrQuadratic();

    inline ::SMESH::LinearOrQuadratic_ptr _this() {
      return (::SMESH::LinearOrQuadratic_ptr) _do_this(::SMESH::LinearOrQuadratic::_PD_repoId);
    }
  };

  class GroupColor :
    public virtual SMESH::_impl_GroupColor,
    public virtual Predicate
  {
  public:
    virtual ~GroupColor();

    inline ::SMESH::GroupColor_ptr _this() {
      return (::SMESH::GroupColor_ptr) _do_this(::SMESH::GroupColor::_PD_repoId);
    }
  };

  class ElemGeomType :
    public virtual SMESH::_impl_ElemGeomType,
    public virtual Predicate
  {
  public:
    virtual ~ElemGeomType();

    inline ::SMESH::ElemGeomType_ptr _this() {
      return (::SMESH::ElemGeomType_ptr) _do_this(::SMESH::ElemGeomType::_PD_repoId);
    }
  };

  class Filter :
    public virtual SMESH::_impl_Filter,
    public virtual POA_SALOME::GenericObj,
      public virtual SMESH_IDSource
  {
  public:
    virtual ~Filter();

    inline ::SMESH::Filter_ptr _this() {
      return (::SMESH::Filter_ptr) _do_this(::SMESH::Filter::_PD_repoId);
    }
  };

  class FilterLibrary :
    public virtual SMESH::_impl_FilterLibrary,
    public virtual POA_SALOME::GenericObj
  {
  public:
    virtual ~FilterLibrary();

    inline ::SMESH::FilterLibrary_ptr _this() {
      return (::SMESH::FilterLibrary_ptr) _do_this(::SMESH::FilterLibrary::_PD_repoId);
    }
  };

  class FilterManager :
    public virtual SMESH::_impl_FilterManager,
    public virtual POA_SALOME::GenericObj
  {
  public:
    virtual ~FilterManager();

    inline ::SMESH::FilterManager_ptr _this() {
      return (::SMESH::FilterManager_ptr) _do_this(::SMESH::FilterManager::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_SMESH
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_SMESH__Filter
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_SMESH__Filter
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_SMESH__Filter
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_SMESH__Filter
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_SMESH__Filter
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_SMESH__Filter
#endif

#endif  // __SMESH__Filter_hh__

