src/SMESH/SMESH_HypoFilter.cxx

   1 //  SMESH SMESH : implementaion of SMESH idl descriptions
   2 //
   3 //  Copyright (C) 2003  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.
  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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //
  24 //  File   : SMESH_HypoFilter.cxx
  25 //  Module : SMESH
  26 //  $Header$
  27
  28 #include "SMESH_HypoFilter.hxx"
  29
  30 #include "SMESH_Hypothesis.hxx"
  31 #include "SMESH_subMesh.hxx"
  32
  33 using namespace std;
  34
  35
  36 //=======================================================================
  37 //function : NamePredicate::Value
  38 //purpose  :
  39 //=======================================================================
  40
  41 bool SMESH_HypoFilter::NamePredicate::IsOk (const SMESH_Hypothesis* aHyp,
  42                                             const TopoDS_Shape&     /*aShape*/ ) const
  43 {
  44   return ( _name == aHyp->GetName() );
  45 }
  46
  47 //=======================================================================
  48 //function : TypePredicate::Value
  49 //purpose  :
  50 //=======================================================================
  51
  52 int SMESH_HypoFilter::TypePredicate::Value( const SMESH_Hypothesis* aHyp ) const
  53 {
  54   return aHyp->GetType();
  55 };
  56
  57 //=======================================================================
  58 //function : DimPredicate::Value
  59 //purpose  :
  60 //=======================================================================
  61
  62 int SMESH_HypoFilter::DimPredicate::Value( const SMESH_Hypothesis* aHyp ) const
  63 {
  64   return aHyp->GetDim();
  65 }
  66
  67 //=======================================================================
  68 //function : ApplicablePredicate::IsOk
  69 //purpose  :
  70 //=======================================================================
  71
  72 bool SMESH_HypoFilter::ApplicablePredicate::IsOk(const SMESH_Hypothesis* aHyp,
  73                                                  const TopoDS_Shape&     /*aShape*/) const
  74 {
  75   return SMESH_subMesh::IsApplicableHypotesis( aHyp, (TopAbs_ShapeEnum)_shapeType );
  76 };
  77
  78 //=======================================================================
  79 //function : ApplicablePredicate::ApplicablePredicate
  80 //purpose  :
  81 //=======================================================================
  82
  83 SMESH_HypoFilter::ApplicablePredicate::ApplicablePredicate( const TopoDS_Shape& theShape )
  84 {
  85   _shapeType = ( theShape.IsNull() ? TopAbs_SHAPE : theShape.ShapeType());
  86 }
  87
  88 //=======================================================================
  89 //function : InstancePredicate::IsOk
  90 //purpose  :
  91 //=======================================================================
  92
  93 bool SMESH_HypoFilter::InstancePredicate::IsOk(const SMESH_Hypothesis* aHyp,
  94                                                const TopoDS_Shape&     /*aShape*/) const
  95 {
  96   return _hypo == aHyp;
  97 }
  98
  99 //=======================================================================
 100 //function : IsAssignedToPredicate::IsOk
 101 //purpose  :
 102 //=======================================================================
 103
 104 bool SMESH_HypoFilter::IsAssignedToPredicate::IsOk(const SMESH_Hypothesis* aHyp,
 105                                                const TopoDS_Shape&     aShape) const
 106 {
 107   return ( !_mainShape.IsNull() && !aShape.IsNull() && _mainShape.IsSame( aShape ));
 108 }
 109
 110 //=======================================================================
 111 //function : SMESH_HypoFilter
 112 //purpose  :
 113 //=======================================================================
 114
 115 SMESH_HypoFilter::SMESH_HypoFilter()
 116 {
 117 }
 118
 119 //=======================================================================
 120 //function : SMESH_HypoFilter
 121 //purpose  :
 122 //=======================================================================
 123
 124 SMESH_HypoFilter::SMESH_HypoFilter( SMESH_HypoPredicate* aPredicate, bool notNagate )
 125 {
 126   add( notNagate ? AND : AND_NOT, aPredicate );
 127 }
 128
 129 //=======================================================================
 130 //function : And
 131 //purpose  :
 132 //=======================================================================
 133
 134 SMESH_HypoFilter & SMESH_HypoFilter::And( SMESH_HypoPredicate* aPredicate )
 135 {
 136   add( AND, aPredicate );
 137   return *this;
 138 }
 139
 140 //=======================================================================
 141 //function : AndNot
 142 //purpose  :
 143 //=======================================================================
 144
 145 SMESH_HypoFilter & SMESH_HypoFilter::AndNot( SMESH_HypoPredicate* aPredicate )
 146 {
 147   add( AND_NOT, aPredicate );
 148   return *this;
 149 }
 150
 151 //=======================================================================
 152 //function : Or
 153 //purpose  :
 154 //=======================================================================
 155
 156 SMESH_HypoFilter & SMESH_HypoFilter::Or( SMESH_HypoPredicate* aPredicate )
 157 {
 158   add( OR, aPredicate );
 159   return *this;
 160 }
 161
 162 //=======================================================================
 163 //function : OrNot
 164 //purpose  : Return predicates
 165 //=======================================================================
 166
 167 SMESH_HypoFilter & SMESH_HypoFilter::OrNot( SMESH_HypoPredicate* aPredicate )
 168 {
 169   add( OR_NOT, aPredicate );
 170   return *this;
 171 }
 172
 173 //=======================================================================
 174 //function : Is
 175 //purpose  :
 176 //=======================================================================
 177
 178 SMESH_HypoPredicate* SMESH_HypoFilter::Is(const SMESH_Hypothesis* theHypo)
 179 {
 180   return new InstancePredicate( theHypo );
 181 }
 182
 183 //=======================================================================
 184 //function : IsAlgo
 185 //purpose  :
 186 //=======================================================================
 187
 188 SMESH_HypoPredicate* SMESH_HypoFilter::IsAlgo()
 189 {
 190   return new TypePredicate( MORE, SMESHDS_Hypothesis::PARAM_ALGO );
 191 }
 192
 193 //=======================================================================
 194 //function : IsGlobal
 195 //purpose  :
 196 //=======================================================================
 197
 198  SMESH_HypoPredicate* SMESH_HypoFilter::IsGlobal(const TopoDS_Shape& theMainShape)
 199 {
 200   return new IsAssignedToPredicate( theMainShape );
 201 }
 202
 203 //=======================================================================
 204 //function : IsAssignedTo
 205 //purpose  :
 206 //=======================================================================
 207
 208  SMESH_HypoPredicate* SMESH_HypoFilter::IsAssignedTo(const TopoDS_Shape& theShape)
 209 {
 210   return new IsAssignedToPredicate( theShape );
 211 }
 212
 213 //=======================================================================
 214 //function : HasName
 215 //purpose  :
 216 //=======================================================================
 217
 218 SMESH_HypoPredicate* SMESH_HypoFilter::HasName(const string & theName)
 219 {
 220   return new NamePredicate( theName );
 221 }
 222
 223 //=======================================================================
 224 //function : HasDim
 225 //purpose  :
 226 //=======================================================================
 227
 228 SMESH_HypoPredicate* SMESH_HypoFilter::HasDim(const int theDim)
 229 {
 230   return new DimPredicate( EQUAL, theDim );
 231 }
 232
 233 //=======================================================================
 234 //function : IsApplicableTo
 235 //purpose  :
 236 //=======================================================================
 237
 238 SMESH_HypoPredicate* SMESH_HypoFilter::IsApplicableTo(const TopoDS_Shape& theShape)
 239 {
 240   return new ApplicablePredicate( theShape );
 241 }
 242
 243 //=======================================================================
 244 //function : HasType
 245 //purpose  :
 246 //=======================================================================
 247
 248 SMESH_HypoPredicate* SMESH_HypoFilter::HasType(const int theHypType)
 249 {
 250   return new TypePredicate( EQUAL, theHypType );
 251 }
 252
 253 //=======================================================================
 254 //function : IsOk
 255 //purpose  :
 256 //=======================================================================
 257
 258 bool SMESH_HypoFilter::IsOk (const SMESH_Hypothesis* aHyp,
 259                              const TopoDS_Shape&     aShape) const
 260 {
 261   if ( myPredicates.empty() )
 262     return true;
 263
 264   bool ok = ( myPredicates.front()->_logical_op <= AND_NOT );
 265   list<SMESH_HypoPredicate*>::const_iterator pred = myPredicates.begin();
 266   for ( ; pred != myPredicates.end(); ++pred )
 267   {
 268     bool ok2 = (*pred)->IsOk( aHyp, aShape );
 269     switch ( (*pred)->_logical_op ) {
 270     case AND:     ok = ok && ok2; break;
 271     case AND_NOT: ok = ok && !ok2; break;
 272     case OR:      ok = ok || ok2; break;
 273     case OR_NOT:  ok = ok || !ok2; break;
 274     default:;
 275     }
 276   }
 277   return ok;
 278 }
 279
 280 //=======================================================================
 281 //function : Init
 282 //purpose  :
 283 //=======================================================================
 284
 285 SMESH_HypoFilter & SMESH_HypoFilter::Init  ( SMESH_HypoPredicate* aPredicate, bool notNagate )
 286 {
 287   list<SMESH_HypoPredicate*>::const_iterator pred = myPredicates.begin();
 288   for ( ; pred != myPredicates.end(); ++pred )
 289     delete *pred;
 290
 291   add( notNagate ? AND : AND_NOT, aPredicate );
 292   return *this;
 293 }
 294
 295
 296 //=======================================================================
 297 //function : IsOk
 298 //purpose  :
 299 //=======================================================================
 300
 301 SMESH_HypoFilter::~SMESH_HypoFilter()
 302 {
 303   Init(0);
 304 }
 305