src/HYDROPy/HYDROData_CalculationCase.sip

   1 // Copyright (C) 2014-2015  EDF-R&D
   2 // This library is free software; you can redistribute it and/or
   3 // modify it under the terms of the GNU Lesser General Public
   4 // License as published by the Free Software Foundation; either
   5 // version 2.1 of the License, or (at your option) any later version.
   6 //
   7 // This library is distributed in the hope that it will be useful,
   8 // but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  10 // Lesser General Public License for more details.
  11 //
  12 // You should have received a copy of the GNU Lesser General Public
  13 // License along with this library; if not, write to the Free Software
  14 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  15 //
  16 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  17 //
  18
  19 %ExportedHeaderCode
  20 #include <HYDROData_CalculationCase.h>
  21 #include <HYDROData_PriorityQueue.h>
  22 %End
  23
  24 enum HYDROData_PriorityType
  25 {
  26   LESS,
  27   GREATER,
  28 };
  29
  30 class HYDROData_CalculationCase : public HYDROData_Entity
  31 {
  32
  33 %TypeHeaderCode
  34 #include <HYDROData_CalculationCase.h>
  35 %End
  36
  37 %ConvertToSubClassCode
  38     switch ( sipCpp->GetKind() )
  39     {
  40       case KIND_CALCULATION:
  41         sipClass = sipClass_HYDROData_CalculationCase;
  42         break;
  43
  44       default:
  45         // We don't recognise the type.
  46         sipClass = NULL;
  47     }
  48 %End
  49
  50 public:
  51
  52   enum PointClassification
  53   {
  54     POINT_OUT,  ///< point is out of zone face
  55     POINT_IN,   ///< point is inside of zone face
  56     POINT_ON    ///< point is on the edge of zone face
  57   };
  58
  59   enum AssignmentMode
  60   {
  61     MANUAL = 0,
  62     AUTOMATIC,
  63   };
  64
  65 public:
  66
  67   enum DataTag
  68   {
  69     DataTag_First = 100,               ///< first tag, to reserve
  70     DataTag_GeometryObject,            ///< reference geometry objects
  71     DataTag_ChildRegion,               ///< child regions
  72     DataTag_Region,                    ///< reference regions
  73     DataTag_Polyline,                  ///< reference boundary polyline
  74     DataTag_GeometryGroup,             ///< reference geometry groups
  75     DataTag_SplitGroups,               ///< reference split groups
  76     DataTag_CustomRules,               ///< custom rules
  77     DataTag_AssignmentMode,            ///< assignment mode
  78     DataTag_StricklerTable,            ///< reference Strickler table
  79     DataTag_LandCover_Obsolete,                 ///< reference land covers
  80     DataTag_CustomLandCoverRules_Obsolete,      ///< custom rules for land covers priority
  81     DataTag_AssignmentLandCoverMode_Obsolete,   ///< assignment mode of land covers priority
  82     DataTag_ChildLandCoverRegion_Obsolete,      ///< child land cover regions
  83     DataTag_LandCoverRegion_Obsolete            ///< reference land cover regions
  84   };
  85
  86 public:
  87   /**
  88    * Add new one reference geometry object for calculation case.
  89    */
  90   bool AddGeometryObject( HYDROData_Object theObject ) [bool ( const Handle_HYDROData_Object& )];
  91   %MethodCode
  92     Handle(HYDROData_Object) aRef =
  93       Handle(HYDROData_Object)::DownCast( createHandle( a0 ) );
  94     if ( !aRef.IsNull() )
  95     {
  96       Py_BEGIN_ALLOW_THREADS
  97       sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddGeometryObject( aRef ):
  98                                sipCpp->AddGeometryObject( aRef );
  99       Py_END_ALLOW_THREADS
 100     }
 101   %End
 102
 103   /**
 104    * Returns all reference geometry objects of calculation case.
 105    */
 106   HYDROData_SequenceOfObjects GetGeometryObjects() const;
 107
 108   /**
 109    * Removes reference geometry object from calculation case.
 110    */
 111   void RemoveGeometryObject( HYDROData_Object theObject )
 112   [void ( const Handle_HYDROData_Object& )];
 113   %MethodCode
 114     Handle(HYDROData_Object) aRef =
 115       Handle(HYDROData_Object)::DownCast( createHandle( a0 ) );
 116     if ( !aRef.IsNull() )
 117     {
 118       Py_BEGIN_ALLOW_THREADS
 119       if ( sipSelfWasArg ) {
 120         sipCpp->HYDROData_CalculationCase::RemoveGeometryObject( aRef );
 121       } else {
 122         sipCpp->RemoveGeometryObject( aRef );
 123       }
 124       Py_END_ALLOW_THREADS
 125     }
 126   %End
 127
 128   /**
 129    * Removes all reference geometry objects from calculation case.
 130    */
 131   void RemoveGeometryObjects();
 132
 133
 134   /**
 135    * Add new one reference geometry group for calculation case.
 136    */
 137   bool AddGeometryGroup( HYDROData_ShapesGroup theGroup ) [bool ( const Handle_HYDROData_ShapesGroup& )];
 138   %MethodCode
 139     Handle(HYDROData_ShapesGroup) aRef =
 140       Handle(HYDROData_ShapesGroup)::DownCast( createHandle( a0 ) );
 141     if ( !aRef.IsNull() )
 142     {
 143       Py_BEGIN_ALLOW_THREADS
 144       sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddGeometryGroup( aRef ):
 145                                sipCpp->AddGeometryGroup( aRef );
 146       Py_END_ALLOW_THREADS
 147     }
 148   %End
 149
 150   /**
 151    * Returns all reference geometry groups of calculation case.
 152    */
 153   HYDROData_SequenceOfObjects GetGeometryGroups() const;
 154
 155   /**
 156    * Removes reference geometry group from calculation case.
 157    */
 158   void RemoveGeometryGroup( HYDROData_ShapesGroup theGroup ) [void ( const Handle_HYDROData_ShapesGroup& )];
 159   %MethodCode
 160     Handle(HYDROData_ShapesGroup) aRef =
 161       Handle(HYDROData_ShapesGroup)::DownCast( createHandle( a0 ) );
 162     if ( !aRef.IsNull() )
 163     {
 164       Py_BEGIN_ALLOW_THREADS
 165       if ( sipSelfWasArg ) {
 166         sipCpp->HYDROData_CalculationCase::RemoveGeometryGroup( aRef );
 167       } else {
 168         sipCpp->RemoveGeometryGroup( aRef );
 169       }
 170       Py_END_ALLOW_THREADS
 171     }
 172   %End
 173
 174   /**
 175    * Removes all reference geometry groups from calculation case.
 176    */
 177   void RemoveGeometryGroups();
 178
 179
 180   /**
 181    * Sets reference boundary polyline object for calculation case.
 182    */
 183   void SetBoundaryPolyline( HYDROData_PolylineXY thePolyline ) [void ( const Handle_HYDROData_PolylineXY& )];
 184   %MethodCode
 185     Handle(HYDROData_PolylineXY) aRef =
 186       Handle(HYDROData_PolylineXY)::DownCast( createHandle( a0 ) );
 187     if ( !aRef.IsNull() )
 188     {
 189       Py_BEGIN_ALLOW_THREADS
 190       if ( sipSelfWasArg ) {
 191         sipCpp->HYDROData_CalculationCase::SetBoundaryPolyline( aRef );
 192       } else {
 193         sipCpp->SetBoundaryPolyline( aRef );
 194       }
 195       Py_END_ALLOW_THREADS
 196     }
 197   %End
 198
 199   /**
 200    * Returns reference boundary polyline object of calculation case.
 201    */
 202   HYDROData_PolylineXY GetBoundaryPolyline() const [Handle_HYDROData_PolylineXY ()];
 203   %MethodCode
 204     Handle(HYDROData_PolylineXY) aRef;
 205
 206     Py_BEGIN_ALLOW_THREADS
 207     aRef = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetBoundaryPolyline() :
 208                            sipCpp->GetBoundaryPolyline();
 209     Py_END_ALLOW_THREADS
 210
 211     sipRes = (HYDROData_PolylineXY*)createPointer( aRef );
 212   %End
 213
 214   /**
 215    * Remove reference boundary polyline object from calculation case.
 216    */
 217   void RemoveBoundaryPolyline();
 218
 219   void SetLandCoverMap( HYDROData_LandCoverMap theLandCoverMap ) [void ( const Handle_HYDROData_LandCoverMap& )];
 220   %MethodCode
 221     Handle(HYDROData_LandCoverMap) aRef =
 222       Handle(HYDROData_LandCoverMap)::DownCast( createHandle( a0 ) );
 223     if ( !aRef.IsNull() )
 224     {
 225       Py_BEGIN_ALLOW_THREADS
 226       if ( sipSelfWasArg ) {
 227         sipCpp->HYDROData_CalculationCase::SetLandCoverMap( aRef );
 228       } else {
 229         sipCpp->SetLandCoverMap( aRef );
 230       }
 231       Py_END_ALLOW_THREADS
 232     }
 233   %End
 234
 235   void SetStricklerTable( HYDROData_StricklerTable theStricklerTable ) [void ( const Handle_HYDROData_StricklerTable& )];
 236    %MethodCode
 237     Handle(HYDROData_StricklerTable) aRef =
 238       Handle(HYDROData_StricklerTable)::DownCast( createHandle( a0 ) );
 239     if ( !aRef.IsNull() )
 240     {
 241       Py_BEGIN_ALLOW_THREADS
 242       if ( sipSelfWasArg ) {
 243         sipCpp->HYDROData_CalculationCase::SetStricklerTable( aRef );
 244       } else {
 245         sipCpp->SetStricklerTable( aRef );
 246       }
 247       Py_END_ALLOW_THREADS
 248     }
 249   %End
 250
 251   /**
 252    * Add new one child region for calculation case.
 253    * The new region is added into the list of reference regions.
 254    * The label of theZone is changed during this operation
 255    * because of new region becomes the new parent for this zone.
 256    */
 257   HYDROData_Region AddNewRegion( HYDROData_Zone theZone ) [Handle_HYDROData_Region ( const Handle_HYDROData_Zone& )];
 258   %MethodCode
 259     Handle(HYDROData_Zone) aRef =
 260       Handle(HYDROData_Zone)::DownCast( createHandle( a0 ) );
 261     Handle(HYDROData_Region) aRes;
 262
 263     if ( !aRef.IsNull() )
 264     {
 265       Py_BEGIN_ALLOW_THREADS
 266       aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddNewRegion( aRef ) :
 267                              sipCpp->AddNewRegion( aRef );
 268       Py_END_ALLOW_THREADS
 269     }
 270
 271     sipRes = (HYDROData_Region*)createPointer( aRes );
 272   %End
 273
 274   /**
 275    * Add new one reference region for calculation case.
 276    * The label of theRegion is changed in case if old parent is not this calculation.
 277    */
 278   bool AddRegion( HYDROData_Region theRegion ) [bool ( const Handle_HYDROData_Region& )];
 279   %MethodCode
 280     Handle(HYDROData_Region) aRef =
 281       Handle(HYDROData_Region)::DownCast( createHandle( a0 ) );
 282     if ( !aRef.IsNull() )
 283     {
 284       Py_BEGIN_ALLOW_THREADS
 285       sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddRegion( aRef ):
 286                                sipCpp->AddRegion( aRef );
 287       Py_END_ALLOW_THREADS
 288     }
 289   %End
 290
 291   /**
 292    * Returns all reference regions of calculation case.
 293    */
 294   HYDROData_SequenceOfObjects GetRegions() const;
 295
 296   /**
 297    * Updates names of regions to correct order.
 298    */
 299   void UpdateRegionsOrder();
 300
 301   /**
 302    * Removes reference region from calculation case.
 303    */
 304   void RemoveRegion( HYDROData_Region theRegion ) [void ( const Handle_HYDROData_Region& )];
 305   %MethodCode
 306     Handle(HYDROData_Region) aRef =
 307       Handle(HYDROData_Region)::DownCast( createHandle( a0 ) );
 308     if ( !aRef.IsNull() )
 309     {
 310       Py_BEGIN_ALLOW_THREADS
 311       if ( sipSelfWasArg ) {
 312         sipCpp->HYDROData_CalculationCase::RemoveRegion( aRef );
 313       } else {
 314         sipCpp->RemoveRegion( aRef );
 315       }
 316       Py_END_ALLOW_THREADS
 317     }
 318   %End
 319
 320   /**
 321    * Removes all reference regions from calculation case.
 322    */
 323   void RemoveRegions();
 324
 325
 326   /**
 327    * Returns all reference geometry groups of calculation case.
 328    */
 329   HYDROData_SequenceOfObjects GetSplitGroups() const;
 330
 331   /**
 332    * Removes all reference geometry groups from calculation case.
 333    */
 334   void RemoveSplitGroups();
 335
 336
 337   /**
 338    * Exports the calculation case data (shell and groups) to GEOM module.
 339    * \param theGeomEngine GEOM module engine
 340    * \param theStudy SALOMEDS study, is used for publishing of GEOM objects
 341    * \return true in case of success
 342    */
 343 //TODO:  virtual bool Export( GEOM::GEOM_Gen_var theGeomEngine,
 344 //                       SALOMEDS::Study_ptr theStudy );
 345
 346         QString Export( int theStudyId ) const;
 347
 348 public:
 349   // Public methods to work with Calculation services
 350
 351   /**
 352    * Returns strickler coefficient for given point.
 353    * \param thePoint the point to examine
 354    * \return result strickler coefficient
 355    */
 356   double GetStricklerCoefficientForPoint( const double theCoordX,
 357                                           const double theCoordY ) const [double ( const gp_XY& ) ];
 358   %MethodCode
 359     gp_XY aPnt( a0, a1 );
 360
 361     Py_BEGIN_ALLOW_THREADS
 362     sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetStricklerCoefficientForPoint( aPnt ) :
 363                              sipCpp->GetStricklerCoefficientForPoint( aPnt );
 364     Py_END_ALLOW_THREADS
 365   %End
 366
 367   /**
 368    * Returns altitude for given point.
 369    * \param thePoint the point to examine
 370    * \return result altitude value
 371    */
 372   double GetAltitudeForPoint( const double theCoordX,
 373                               const double theCoordY ) const [double ( const gp_XY& )];
 374   %MethodCode
 375     gp_XY aPnt( a0, a1 );
 376
 377     Py_BEGIN_ALLOW_THREADS
 378     sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudeForPoint( aPnt ) :
 379                              sipCpp->GetAltitudeForPoint( aPnt );
 380     Py_END_ALLOW_THREADS
 381   %End
 382
 383   /**
 384    * Returns altitude for given point on given region.
 385    * \param thePoint the point to examine
 386    * \param theRegion reference region to check
 387    * \return result altitude value
 388    */
 389   double GetAltitudeForPoint( const double     theCoordX,
 390                               const double     theCoordY,
 391                               HYDROData_Region theRegion ) const
 392   [double ( const gp_XY&, const Handle_HYDROData_Region& )];
 393   %MethodCode
 394     gp_XY aPnt( a0, a1 );
 395     Handle(HYDROData_Region) aRefRegion =
 396       Handle(HYDROData_Region)::DownCast( createHandle( a2 ) );
 397
 398     Py_BEGIN_ALLOW_THREADS
 399     sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudeForPoint( aPnt, aRefRegion ) :
 400                              sipCpp->GetAltitudeForPoint( aPnt, aRefRegion );
 401     Py_END_ALLOW_THREADS
 402   %End
 403
 404   /**
 405    * Returns altitude for given point on given zone.
 406    * \param thePoint the point to examine
 407    * \param theZone reference zone to check
 408    * \return result altitude value
 409    */
 410   double GetAltitudeForPoint( const double theCoordX,
 411                               const double theCoordY,
 412                               HYDROData_Zone theZone ) const
 413   [double ( const gp_XY&, const Handle_HYDROData_Zone& )];
 414   %MethodCode
 415     gp_XY aPnt( a0, a1 );
 416     Handle(HYDROData_Zone) aRefZone =
 417       Handle(HYDROData_Zone)::DownCast( createHandle( a2 ) );
 418
 419     Py_BEGIN_ALLOW_THREADS
 420     sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudeForPoint( aPnt, aRefZone ) :
 421                              sipCpp->GetAltitudeForPoint( aPnt, aRefZone );
 422     Py_END_ALLOW_THREADS
 423   %End
 424
 425   /**
 426    * Returns altitudes for given points on given region.
 427    * \param thePoints the points to examine
 428    * \param theZone reference region to check
 429    * \return result altitude value
 430    */
 431   NCollection_Sequence<double> GetAltitudesForPoints( const NCollection_Sequence<double>& theCoordsX,
 432                                                       const NCollection_Sequence<double>& theCoordsY,
 433                                                       HYDROData_Region                    theRegion,
 434                                                       int                                 theMethod = 0) const
 435   [NCollection_Sequence<double> ( const NCollection_Sequence<gp_XY>&, const Handle_HYDROData_Region&, int)];
 436   %MethodCode
 437
 438     NCollection_Sequence<gp_XY> aPnts;
 439
 440     int aLen = qMin( a0->Length(), a1->Length() );
 441     for ( int i = 1; i <= aLen; ++i )
 442     {
 443       gp_XY aPnt( a0->Value( i ), a1->Value( i ) );
 444       aPnts.Append( aPnt );
 445     }
 446
 447     Handle(HYDROData_Region) aRefRegion =
 448       Handle(HYDROData_Region)::DownCast( createHandle( a2 ) );
 449     int aMethod = a3;
 450
 451     NCollection_Sequence<double> aRes;
 452     Py_BEGIN_ALLOW_THREADS
 453     aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudesForPoints( aPnts, aRefRegion, aMethod ) :
 454                            sipCpp->GetAltitudesForPoints( aPnts, aRefRegion, aMethod );
 455     Py_END_ALLOW_THREADS
 456
 457     sipRes = new NCollection_Sequence<double>( aRes );
 458   %End
 459
 460   std::vector<double> GetStricklerCoefficientForPoints( const NCollection_Sequence<double>& theCoordsX,
 461                                                         const NCollection_Sequence<double>& theCoordsY,
 462                                                         double DefValue,
 463                                                         bool UseMax ) const
 464   [std::vector<double> ( const NCollection_Sequence<gp_XY>&, double, bool)];
 465   %MethodCode
 466   std::vector<gp_XY> aPnts;
 467   int aLen = qMin( a0->Length(), a1->Length() );
 468   for ( int i = 1; i <= aLen; ++i )
 469   {
 470     gp_XY aPnt( a0->Value( i ), a1->Value( i ) );
 471     aPnts.push_back( aPnt );
 472   }
 473   std::vector<double> aRes;
 474   Py_BEGIN_ALLOW_THREADS
 475   aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetStricklerCoefficientForPoints( aPnts, a2, a3 ) :
 476                          sipCpp->GetStricklerCoefficientForPoints( aPnts, a2, a3 );
 477   Py_END_ALLOW_THREADS
 478   sipRes = new std::vector<double>( aRes );
 479   %End
 480
 481
 482   /**
 483    * Returns altitudes for given points on given zone.
 484    * \param thePoints the points to examine
 485    * \param theZone reference zone to check
 486    * \return result altitude value
 487    */
 488   NCollection_Sequence<double> GetAltitudesForPoints( const NCollection_Sequence<double>& theCoordsX,
 489                                                       const NCollection_Sequence<double>& theCoordsY,
 490                                                       HYDROData_Zone                      theZone,
 491                                                       int                                 theMethod = 0) const
 492   [NCollection_Sequence<double> ( const NCollection_Sequence<gp_XY>&, const Handle_HYDROData_Zone&, int )];
 493   %MethodCode
 494
 495     NCollection_Sequence<gp_XY> aPnts;
 496
 497     int aLen = qMin( a0->Length(), a1->Length() );
 498     for ( int i = 1; i <= aLen; ++i )
 499     {
 500       gp_XY aPnt( a0->Value( i ), a1->Value( i ) );
 501       aPnts.Append( aPnt );
 502     }
 503
 504     Handle(HYDROData_Zone) aRefZone =
 505       Handle(HYDROData_Zone)::DownCast( createHandle( a2 ) );
 506     int aMethod = a3;
 507
 508     NCollection_Sequence<double> aRes;
 509     Py_BEGIN_ALLOW_THREADS
 510     aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudesForPoints( aPnts, aRefZone, aMethod ) :
 511                            sipCpp->GetAltitudesForPoints( aPnts, aRefZone, aMethod );
 512     Py_END_ALLOW_THREADS
 513
 514     sipRes = new NCollection_Sequence<double>( aRes );
 515   %End
 516
 517   /**
 518    * Returns region to which the point is belongs.
 519    * \param thePoint the point to examine
 520    * \return result region
 521    */
 522   HYDROData_Region GetRegionFromPoint( const double theCoordX,
 523                                        const double theCoordY ) const
 524   [Handle_HYDROData_Region ( const gp_XY& )];
 525   %MethodCode
 526     Handle(HYDROData_Region) aRes;
 527
 528     gp_XY aPnt( a0, a1 );
 529
 530     Py_BEGIN_ALLOW_THREADS
 531     aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetRegionFromPoint( aPnt ) :
 532                            sipCpp->GetRegionFromPoint( aPnt );
 533     Py_END_ALLOW_THREADS
 534
 535     sipRes = (HYDROData_Region*)createPointer( aRes );
 536   %End
 537
 538   /**
 539    * Returns zone to which the point is belongs.
 540    * \param thePoint the point to examine
 541    * \return result zone
 542    */
 543   HYDROData_Zone GetZoneFromPoint( const double theCoordX,
 544                                    const double theCoordY ) const
 545   [Handle_HYDROData_Zone ( const gp_XY& )];
 546   %MethodCode
 547     Handle(HYDROData_Zone) aRes;
 548
 549     gp_XY aPnt( a0, a1 );
 550
 551     Py_BEGIN_ALLOW_THREADS
 552     aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetZoneFromPoint( aPnt ) :
 553                            sipCpp->GetZoneFromPoint( aPnt );
 554     Py_END_ALLOW_THREADS
 555
 556     sipRes = (HYDROData_Zone*)createPointer( aRes );
 557   %End
 558
 559   /**
 560    * Returns classification of point for given zone.
 561    * \param thePoint the point to examine
 562    * \param theZone the zone to examine
 563    * \return result classification
 564    */
 565   PointClassification GetPointClassification( const double theCoordX,
 566                                               const double theCoordY,
 567                                               HYDROData_Zone theZone ) const
 568   [PointClassification ( const gp_XY&, const Handle_HYDROData_Zone& )];
 569   %MethodCode
 570     gp_XY aPnt( a0, a1 );
 571
 572     Handle(HYDROData_Zone) aRef =
 573       Handle(HYDROData_Zone)::DownCast( createHandle( a2 ) );
 574
 575     Py_BEGIN_ALLOW_THREADS
 576     sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetPointClassification( aPnt, aRef ) :
 577                              sipCpp->GetPointClassification( aPnt, aRef );
 578     Py_END_ALLOW_THREADS
 579   %End
 580
 581
 582   void ClearRules( HYDROData_CalculationCase::DataTag theDataTag );
 583
 584   void AddRule( HYDROData_Entity                   theObject1,
 585                 HYDROData_PriorityType             thePriority,
 586                 HYDROData_Entity                   theObject2,
 587                 HYDROData_Zone::MergeType          theMergeType,
 588                                 HYDROData_CalculationCase::DataTag theDataTag )
 589   [void ( const Handle_HYDROData_Entity&, HYDROData_PriorityType, const Handle_HYDROData_Entity&, HYDROData_Zone::MergeType, HYDROData_CalculationCase::DataTag )];
 590   %MethodCode
 591     Handle(HYDROData_Entity) anObject1 =
 592       Handle(HYDROData_Entity)::DownCast( createHandle( a0 ) );
 593     Handle(HYDROData_Entity) anObject2 =
 594       Handle(HYDROData_Entity)::DownCast( createHandle( a2 ) );
 595
 596     Py_BEGIN_ALLOW_THREADS
 597     sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddRule( anObject1, a1, anObject2, a3, a4 ) :
 598                     sipCpp->AddRule( anObject1, a1, anObject2, a3, a4 );
 599     Py_END_ALLOW_THREADS
 600   %End
 601
 602   QString DumpRules();
 603
 604   void SetAssignmentMode( AssignmentMode theMode );
 605   AssignmentMode GetAssignmentMode() const;
 606
 607 protected:
 608
 609   /**
 610    * Creates new object in the internal data structure. Use higher level objects
 611    * to create objects with real content.
 612    */
 613   HYDROData_CalculationCase();
 614
 615   /**
 616    * Destructs properties of the object and object itself, removes it from the document.
 617    */
 618   ~HYDROData_CalculationCase();
 619 };
 620
 621