idl/SMESH_Gen.idl

   1 // Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //  File   : SMESH_Gen.idl
  23 //  Author : Paul RASCLE, EDF
  24
  25 #ifndef _SMESH_GEN_IDL_
  26 #define _SMESH_GEN_IDL_
  27
  28 #include "SALOME_Exception.idl"
  29 #include "SALOME_Component.idl"
  30 #include "SALOMEDS.idl"
  31
  32 #include "GEOM_Gen.idl"
  33
  34 #include "SMESH_Mesh.idl"
  35 #include "SMESH_Hypothesis.idl"
  36 #include "SMESH_smIdType.idl"
  37
  38 module SMESH
  39 {
  40   typedef sequence<SALOMEDS::SObject> sobject_list;
  41   typedef sequence<GEOM::GEOM_Object> object_array;
  42   typedef sequence<SMESH_Mesh>        mesh_array;
  43
  44   interface FilterManager;
  45   interface SMESH_Pattern;
  46   interface Measurements;
  47   interface MG_ADAPT;
  48   interface MG_ADAPT_OBJECT;
  49
  50   /*!
  51    * Tags definition
  52    */
  53   // Top level
  54   const long Tag_HypothesisRoot = 1; // hypotheses root
  55   const long Tag_AlgorithmsRoot = 2; // algorithms root
  56   const long Tag_FirstMeshRoot  = 3; // first mesh root
  57   // Mesh/Submesh
  58   const long Tag_RefOnShape             = 1; // references to shape
  59   const long Tag_RefOnAppliedHypothesis = 2; // applied hypotheses root
  60   const long Tag_RefOnAppliedAlgorithms = 3; // applied algorithms root
  61   // Mesh only: sub-meshes roots by type
  62   const long Tag_FirstSubMesh           =  4;
  63   const long Tag_SubMeshOnVertex        =  4;
  64   const long Tag_SubMeshOnEdge          =  5;
  65   const long Tag_SubMeshOnWire          =  6;
  66   const long Tag_SubMeshOnFace          =  7;
  67   const long Tag_SubMeshOnShell         =  8;
  68   const long Tag_SubMeshOnSolid         =  9;
  69   const long Tag_SubMeshOnCompound      = 10;
  70   const long Tag_LastSubMesh            = 10;
  71   // Mesh only: group roots by type
  72   const long Tag_FirstGroup             = 11;
  73   const long Tag_NodeGroups             = 11;
  74   const long Tag_EdgeGroups             = 12;
  75   const long Tag_FaceGroups             = 13;
  76   const long Tag_VolumeGroups           = 14;
  77   const long Tag_0DElementsGroups       = 15;
  78   const long Tag_BallElementsGroups     = 16;
  79   const long Tag_LastGroup              = 16;
  80
  81   /*!
  82    * Hypothesis definition error
  83    */
  84   struct AlgoStateError
  85   {
  86     Hypothesis_Status  state;
  87     string             algoName;
  88     long               algoDim;
  89     boolean            isGlobalAlgo;
  90   };
  91   typedef sequence<AlgoStateError> algo_error_array;
  92
  93   /*!
  94    * Mesh computation error
  95    */
  96   enum ComputeErrorName
  97   {
  98     COMPERR_OK            ,
  99     COMPERR_BAD_INPUT_MESH,  // wrong mesh on lower submesh
 100     COMPERR_STD_EXCEPTION ,  // some std exception raised
 101     COMPERR_OCC_EXCEPTION ,  // OCC exception raised
 102     COMPERR_SLM_EXCEPTION ,  // SALOME exception raised
 103     COMPERR_EXCEPTION     ,  // other exception raised
 104     COMPERR_MEMORY_PB     ,  // memory allocation problem
 105     COMPERR_ALGO_FAILED   ,  // computation failed
 106     COMPERR_BAD_SHAPE     ,  // bad geometry
 107     COMPERR_WARNING       ,  // algo reports error but sub-mesh is computed anyway
 108     COMPERR_CANCELED      ,  // compute canceled
 109     COMPERR_NO_MESH_ON_SHAPE,// no mesh elements assigned to sub-mesh
 110     COMPERR_BAD_PARMETERS    // incorrect hypotheses parameters
 111   };
 112   struct ComputeError
 113   {
 114     short   code;       // ComputeErrorName or, if negative, algo specific code
 115     string  comment;    // textual problem description
 116     string  algoName;
 117     short   subShapeID; // id of sub-shape of a shape to mesh
 118     boolean hasBadMesh; // there are elements preventing computation available for visualization
 119   };
 120   typedef sequence<ComputeError> compute_error_array;
 121
 122   /*!
 123    * Way to initialize hypothesis
 124    */
 125   struct HypInitParams
 126   {
 127     short   way; // 0 - by mesh, 1 - by geometry size + preferred parameters, 2 - by averageLength
 128     double  averageLength;
 129     boolean quadDominated;
 130   };
 131
 132   interface SMESH_Gen : Engines::EngineComponent, SALOMEDS::Driver
 133   {
 134     //GEOM::GEOM_Gen SetGeomEngine( in string containerLoc );
 135     void SetGeomEngine( in GEOM::GEOM_Gen geomcompo );
 136
 137     FilterManager CreateFilterManager();
 138
 139     SMESH_Pattern GetPattern();
 140
 141     Measurements  CreateMeasurements();
 142
 143     /*!
 144       Set the current mode
 145      */
 146     void SetEmbeddedMode( in boolean theMode );
 147
 148     /*!
 149       Get the current mode
 150      */
 151     boolean IsEmbeddedMode();
 152
 153     /*!
 154       Update the study
 155      */
 156     void UpdateStudy();
 157
 158     /*!
 159       Set enable publishing in the study
 160      */
 161     void SetEnablePublish( in boolean theIsEnablePublish );
 162
 163     /*!
 164       Get enable publishing in the study
 165      */
 166     boolean IsEnablePublish();
 167
 168     /*!
 169      * Create a hypothesis that can be shared by different parts of the mesh.
 170      * An hypothesis is either:
 171      * - a method used to generate or modify a part of the mesh (algorithm).
 172      * - a parameter or a law used by an algorithm.
 173      * Algorithms are 1D, 2D or 3D.
 174      */
 175     SMESH_Hypothesis CreateHypothesis( in string theHypName,
 176                                        in string theLibName )
 177       raises ( SALOME::SALOME_Exception );
 178
 179     /*!
 180      * Create a hypothesis and initialize it by average length
 181      */
 182     SMESH_Hypothesis CreateHypothesisByAverageLength( in string  theHypName,
 183                                                       in string  theLibName,
 184                                                       in double  theAverageLength,
 185                                                       in boolean theQuadDominated)
 186       raises ( SALOME::SALOME_Exception );
 187
 188     /*!
 189      * Return a hypothesis holding parameter values corresponding either to the mesh
 190      * existing on the given geometry or to size of the geometry.
 191      * The returned hypothesis may be the one existing in a study and used
 192      * to compute the mesh, or a temporary one created just to pass parameter
 193      * values.
 194      */
 195     SMESH_Hypothesis GetHypothesisParameterValues( in string            theHypName,
 196                                                    in string            theLibName,
 197                                                    in SMESH_Mesh        theMesh,
 198                                                    in GEOM::GEOM_Object theGeom,
 199                                                    in HypInitParams     theWay)
 200       raises ( SALOME::SALOME_Exception );
 201
 202     /*!
 203      * Returns \c True if a hypothesis is assigned to a sole sub-mesh in a current Study
 204      *  \param [in] theHyp - the hypothesis of interest
 205      *  \param [out] theMesh - the sole mesh using \a theHyp
 206      *  \param [out] theShape - the sole geometry \a theHyp is assigned to
 207      *  \return boolean - \c True if \a theMesh and \a theShape are sole using \a theHyp
 208      */
 209     boolean GetSoleSubMeshUsingHyp( in SMESH_Hypothesis   theHyp,
 210                                     out SMESH_Mesh        theMesh,
 211                                     out GEOM::GEOM_Object theShape);
 212
 213     /*!
 214      * Sets number of segments per diagonal of boundary box of geometry by which
 215      * default segment length of appropriate 1D hypotheses is defined
 216      */
 217     void SetBoundaryBoxSegmentation( in long theNbSegments ) raises ( SALOME::SALOME_Exception );
 218     /*!
 219      * \brief Sets default number of segments per edge
 220      */
 221     void SetDefaultNbSegments( in long theNbSegments) raises ( SALOME::SALOME_Exception );
 222
 223     /*!
 224      * Set the object name
 225      */
 226     void SetName( in string theObjectIOR,
 227                   in string theObjectName )
 228       raises ( SALOME::SALOME_Exception );
 229
 230     /*!
 231      * Create a Mesh object, given a geometry shape.
 232      * Mesh is created empty (no points, no elements).
 233      * Shape is explored via GEOM_Client to create local copies.
 234      * of TopoDS_Shapes and bind CORBA references of shape & subshapes
 235      * with TopoDS_Shapes
 236      */
 237     SMESH_Mesh CreateMesh( in GEOM::GEOM_Object theObject )
 238       raises ( SALOME::SALOME_Exception );
 239
 240     /*!
 241      * Create an empty mesh object
 242      */
 243     SMESH_Mesh CreateEmptyMesh()
 244       raises ( SALOME::SALOME_Exception );
 245
 246     /*!
 247      * Create Mesh object importing data from given UNV file
 248      * (UNV supported version is I-DEAS 10)
 249      */
 250     SMESH_Mesh CreateMeshesFromUNV( in string theFileName )
 251       raises ( SALOME::SALOME_Exception );
 252
 253     /*!
 254      * Create Mesh object(s) importing data from given MED file
 255      */
 256      mesh_array CreateMeshesFromMED( in string theFileName,
 257                                      out SMESH::DriverMED_ReadStatus theStatus )
 258        raises ( SALOME::SALOME_Exception );
 259
 260     /*!
 261      * Create Mesh object(s) importing data from given MED file
 262      */
 263      mesh_array CreateMeshesFromSAUV( in string theFileName,
 264                                       out SMESH::DriverMED_ReadStatus theStatus )
 265        raises ( SALOME::SALOME_Exception );
 266
 267     /*!
 268      * Create Mesh object importing data from given STL file
 269      */
 270     SMESH_Mesh CreateMeshesFromSTL( in string theFileName )
 271       raises ( SALOME::SALOME_Exception );
 272
 273     /*!
 274      * Create Mesh object(s) importing data from given CGNS file
 275      */
 276     mesh_array CreateMeshesFromCGNS( in string theFileName,
 277                                      out SMESH::DriverMED_ReadStatus theStatus )
 278       raises ( SALOME::SALOME_Exception );
 279
 280     /*!
 281      * Create Mesh object importing data from given GMF file
 282      *  \param theFileName - a name of file to import
 283      *  \param theMakeRequiredGroups - if true, groups of required entities will be created
 284      */
 285     SMESH_Mesh CreateMeshesFromGMF( in string               theFileName,
 286                                     in boolean              theMakeRequiredGroups,
 287                                     out SMESH::ComputeError theError)
 288       raises ( SALOME::SALOME_Exception );
 289
 290     /*!
 291      * Create a mesh by copying a part of another mesh
 292      *  \param meshPart - a part of mesh to copy
 293      *  \param meshName - a name of the new mesh
 294      *  \param toCopyGroups - to create in the new mesh groups
 295      *                        the copied elements belongs to
 296      *  \param toKeepIDs - to preserve IDs of the copied elements or not
 297      */
 298     SMESH_Mesh CopyMesh(in SMESH_IDSource meshPart,
 299                         in string         meshName,
 300                         in boolean        toCopyGroups,
 301                         in boolean        toKeepIDs)
 302       raises ( SALOME::SALOME_Exception );
 303
 304     /*!
 305      * Create a mesh by copying definitions of another mesh to a given geometry
 306      *  \param sourceMesh - a mesh to copy
 307      *  \param newGeometry - a new geometry
 308      *  \param meshName - a name of the new mesh
 309      *  \param toCopyGroups - to create groups in the new mesh
 310      *  \param toReuseHypotheses - if True, existing hypothesis will be used by the new mesh,
 311      *         otherwise new hypotheses with the same parameters will be created for the new mesh.
 312      *  \param toCopyElements - to copy mesh elements of same sub-shapes of the two geometries
 313      *  \param newMesh - return a new mesh
 314      *  \param newGroups - return new groups
 315      *  \param newSubmeshes - return new sub-meshes
 316      *  \param newHypotheses - return new algorithms and hypotheses
 317      *  \param invalidEntries - return study entries of objects whose
 318      *         counterparts are not found in the newGeometry, followed by entries
 319      *         of mesh sub-objects that are invalid because they depend on a not found
 320      *         preceding sub-shape
 321      */
 322     boolean CopyMeshWithGeom( in SMESH_Mesh        sourceMesh,
 323                               in GEOM::GEOM_Object newGeometry,
 324                               in string            meshName,
 325                               in boolean           toCopyGroups,
 326                               in boolean           toReuseHypotheses,
 327                               in boolean           toCopyElements,
 328                               out SMESH_Mesh       newMesh,
 329                               out ListOfGroups     newGroups,
 330                               out submesh_array    newSubmeshes,
 331                               out ListOfHypothesis newHypotheses,
 332                               out string_array     invalidEntries)
 333       raises ( SALOME::SALOME_Exception );
 334
 335     /*!
 336      * Concatenate the given meshes or groups into one mesh,
 337      * optionally to theMeshToAppendTo.
 338      * Union groups with the same name and type if
 339      * theUniteIdenticalGroups flag is true.
 340      * Merge coincident nodes and elements if
 341      * theMergeNodesAndElements flag is true.
 342      */
 343     SMESH_Mesh Concatenate(in ListOfIDSources theMeshesArray,
 344                            in boolean         theUniteIdenticalGroups,
 345                            in boolean         theMergeNodesAndElements,
 346                            in double          theMergeTolerance,
 347                            in SMESH_Mesh      theMeshToAppendTo)
 348       raises ( SALOME::SALOME_Exception );
 349
 350     /*!
 351      * Concatenate the given meshes into one mesh,
 352      * optionally to theMeshToAppendTo.
 353      * Union groups with the same name and type if
 354      * theUniteIdenticalGroups flag is true.
 355      * Merge coincident nodes and elements if
 356      * theMergeNodesAndElements flag is true.
 357      * Create the groups of all elements from initial meshes.
 358      */
 359     SMESH_Mesh ConcatenateWithGroups(in ListOfIDSources theMeshesArray,
 360                                      in boolean         theUniteIdenticalGroups,
 361                                      in boolean         theMergeNodesAndElements,
 362                                      in double          theMergeTolerance,
 363                                      in SMESH_Mesh      theMeshToAppendTo)
 364       raises ( SALOME::SALOME_Exception );
 365
 366     /*!
 367      * Mesh a subShape.
 368      * First, verify list of hypothesis associated with the Sub-shape,
 369      * return NOK if hypothesis are not sufficient
 370      */
 371     boolean Compute( in SMESH_Mesh        theMesh,
 372                      in GEOM::GEOM_Object theSubObject )
 373       raises ( SALOME::SALOME_Exception );
 374
 375     /*!
 376      * Cancel a computation.
 377      */
 378     void CancelCompute( in SMESH_Mesh        theMesh,
 379                         in GEOM::GEOM_Object theSubObject );
 380
 381     /*!
 382      * Return true if hypotheses are defined well
 383      */
 384     boolean IsReadyToCompute( in SMESH_Mesh        theMesh,
 385                               in GEOM::GEOM_Object theSubObject )
 386       raises ( SALOME::SALOME_Exception );
 387
 388     /*!
 389      * Evaluates size of prospective mesh on a shape
 390      */
 391     smIdType_array  Evaluate(in SMESH_Mesh        theMesh,
 392                              in GEOM::GEOM_Object theSubObject)
 393       raises ( SALOME::SALOME_Exception );
 394
 395     /*!
 396      * Calculate Mesh as preview till indicated dimension
 397      * First, verify list of hypothesis associated with the Sub-shape.
 398      * Return mesh preview structure
 399      */
 400     MeshPreviewStruct Precompute( in SMESH_Mesh        theMesh,
 401                                   in GEOM::GEOM_Object theSubObject,
 402                                   in Dimension         theDimension,
 403                                   inout long_array    theShapesId )
 404       raises ( SALOME::SALOME_Exception );
 405
 406     /*!
 407      * Return errors of hypotheses definition
 408      * algo_error_array is empty if everything is OK
 409      */
 410     algo_error_array GetAlgoState( in SMESH_Mesh        theMesh,
 411                                    in GEOM::GEOM_Object theSubObject )
 412       raises ( SALOME::SALOME_Exception );
 413
 414     /*!
 415      * Return errors of mesh computation
 416      * compute_error_array is empty if everything is OK
 417      */
 418     compute_error_array GetComputeErrors( in SMESH_Mesh        theMesh,
 419                                           in GEOM::GEOM_Object theSubObject )
 420       raises ( SALOME::SALOME_Exception );
 421
 422     /*!
 423      * Return mesh elements preventing computation of a sub-shape
 424      */
 425     MeshPreviewStruct GetBadInputElements( in SMESH_Mesh theMesh,
 426                                            in short      theSubShapeID )
 427       raises ( SALOME::SALOME_Exception );
 428
 429     /*!
 430      * Create groups of elements preventing computation of a sub-shape
 431      */
 432     SMESH::ListOfGroups MakeGroupsOfBadInputElements( in SMESH_Mesh theMesh,
 433                                                       in short      theSubShapeID,
 434                                                       in string     theGroupName)
 435       raises ( SALOME::SALOME_Exception );
 436
 437     /*!
 438      * Return indices of faces, edges and vertices of given sub-shapes
 439      * within theMainObject
 440      */
 441     long_array GetSubShapesId( in GEOM::GEOM_Object theMainObject,
 442                                in object_array      theListOfSubObjects )
 443        raises ( SALOME::SALOME_Exception );
 444
 445     /*!
 446      * Return geometrical object the given element is built on.
 447      * The returned geometrical object, if not nil, is either found in the
 448      * study or is published by this method with the given name
 449      */
 450     GEOM::GEOM_Object GetGeometryByMeshElement( in SMESH_Mesh theMesh,
 451                                                 in smIdType   theElementID,
 452                                                 in string     theGeomName)
 453       raises ( SALOME::SALOME_Exception );
 454
 455     /*!
 456      * Return geometrical object the given element is built on.
 457      * The returned geometrical object not published in study by this method.
 458      */
 459     GEOM::GEOM_Object FindGeometryByMeshElement( in SMESH_Mesh theMesh,
 460                                                  in smIdType   theElementID)
 461       raises ( SALOME::SALOME_Exception );
 462
 463     /*!
 464      * \brief Return id of object, registered in current study context
 465      *
 466      * Can be used to check if the object was created in the same container, as this engine.
 467      */
 468     long GetObjectId(in Object theObject);
 469
 470     /*!
 471      * \brief Get version of MED format being used.
 472      */
 473     string GetMEDFileVersion();
 474
 475     /*!
 476      * \brief Get MED version of the file by its name.
 477      */
 478     string GetMEDVersion(in string theFileName);
 479
 480     /*!
 481      * \brief Check compatibility of file with MED format being used, for read only.
 482      */
 483     boolean CheckCompatibility(in string theFileName);
 484
 485     /*!
 486      * \brief Check compatibility of file with MED format being used, for append on write.
 487      */
 488     boolean CheckWriteCompatibility(in string theFileName);
 489
 490     /*!
 491      * \brief Get names of meshes defined in file with the specified name.
 492      */
 493     string_array GetMeshNames(in string theFileName);
 494
 495     /*!
 496      * \brief Moves objects to the specified position
 497      *  \param what objects being moved
 498      *  \param where parent object where objects are moved to
 499      *  \param row position in the parent object's children list at which objects are moved
 500      *
 501      * This function is used in the drag-n-drop functionality.
 502      */
 503     void Move( in sobject_list what,
 504                in SALOMEDS::SObject where,
 505                in long row );
 506     /*!
 507      * Returns true if algorithm can be used to mesh a given geometry
 508      *  \param theAlgoType - the algorithm type
 509      *  \param theLibName - a name of the Plug-in library implementing the algorithm
 510      *  \param theShapeObject - the geometry to mesh
 511      *  \param toCheckAll - if \c True, returns \c True if all shapes are meshable,
 512      *         else, returns \c True if at least one shape is meshable
 513      */
 514     boolean IsApplicable( in string             theAlgoType,
 515                           in string             theLibName,
 516                           in GEOM::GEOM_Object  theShapeObject,
 517                           in boolean            toCheckAll );
 518
 519
 520     /*!
 521      * Return indices of elements, which are located inside the sphere
 522      *  \param theSource - mesh, sub-mesh or group
 523      *  \param theElemType - mesh element type
 524      *  \param theX - x coordinate of the center of the sphere
 525      *  \param theY - y coordinate of the center of the sphere
 526      *  \param theZ - y coordinate of the center of the sphere
 527      *  \param theR - radius of the sphere
 528      */
 529     long_array GetInsideSphere( in SMESH_IDSource theSource,
 530                                 in ElementType    theElemType,
 531                                 in double theX,
 532                                 in double theY,
 533                                 in double theZ,
 534                                 in double theR );
 535
 536     /*!
 537      * Return indices of elements, which are located inside the box
 538      *  \param theSource - mesh, sub-mesh or group
 539      *  \param theElemType - mesh element type
 540      *  \param theX1 - x coordinate of the first opposite point
 541      *  \param theY1 - y coordinate of the first opposite point
 542      *  \param theZ1 - y coordinate of the first opposite point
 543      *  \param theX2 - x coordinate of the second opposite point
 544      *  \param theY2 - y coordinate of the second opposite point
 545      *  \param theZ2 - y coordinate of the second opposite point
 546      */
 547     long_array GetInsideBox( in SMESH_IDSource theSource,
 548                              in ElementType    theElemType,
 549                              in double theX1,
 550                              in double theY1,
 551                              in double theZ1,
 552                              in double theX2,
 553                              in double theY2,
 554                              in double theZ2);
 555     /*!
 556      * Return indices of elements, which are located inside the box
 557      *  \param theSource - mesh, sub-mesh or group
 558      *  \param theElemType - mesh element type
 559      *  \param theX - x coordinate of the cented of the bottom face
 560      *  \param theY - y coordinate of the cented of the bottom face
 561      *  \param theZ - y coordinate of the cented of the bottom face
 562      *  \param theDX - x coordinate of the cented of the base vector
 563      *  \param theDY - y coordinate of the cented of the base vector
 564      *  \param theDZ - z coordinate of the cented of the base vector
 565      *  \param theH - height of the cylinder
 566      *  \param theR - radius of the cylinder
 567      */
 568     long_array GetInsideCylinder( in SMESH_IDSource theSource,
 569                                   in ElementType    theElemType,
 570                                   in double theX,
 571                                   in double theY,
 572                                   in double theZ,
 573                                   in double theDX,
 574                                   in double theDY,
 575                                   in double theDZ,
 576                                   in double theH,
 577                                   in double theR );
 578     /*!
 579      * Return indices of elements, which are located inside the geometry
 580      *  \param theSource - mesh, sub-mesh or group
 581      *  \param theElemType - mesh element type
 582      *  \param theGeom - geometrical object
 583      *  \param theTolerance - tolerance for selection.
 584      */
 585     long_array GetInside( in SMESH_IDSource theSource,
 586                           in ElementType    theElemType,
 587                           in GEOM::GEOM_Object theGeom,
 588                           in double theTolerance );
 589
 590     MG_ADAPT CreateMG_ADAPT();
 591     MG_ADAPT_OBJECT Adaptation(in string adaptType);
 592     MG_ADAPT CreateAdaptationHypothesis();
 593   };
 594
 595 };
 596
 597 #endif