src/Notebook/SALOME_EvalSet.cxx

   1 //  Copyright (C) 2007-2008  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.
  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   : SALOME_EvalSet.cxx
  23 //  Author : Peter KURNEV
  24 //  Module : SALOME
  25
  26
  27 #include <SALOME_EvalSet.hxx>
  28 //
  29 #include <math.h>
  30 #include <SALOME_Eval.hxx>
  31
  32 int toInt(const SALOME_String& str, bool *ok);
  33 double toDouble(const SALOME_String& str, bool *ok);
  34 SALOME_String toLower(const SALOME_String& str);
  35 SALOME_String toUpper(const SALOME_String& str);
  36
  37 //=======================================================================
  38 //function : SALOME_EvalSet
  39 //purpose  :
  40 //=======================================================================
  41 SALOME_EvalSet::SALOME_EvalSet()
  42 {
  43 }
  44 //=======================================================================
  45 //function : SALOME_EvalSet::~SALOME_EvalSet
  46 //purpose  :
  47 //=======================================================================
  48 SALOME_EvalSet::~SALOME_EvalSet()
  49 {
  50 }
  51 //=======================================================================
  52 //function : SALOME_EvalSet::createValue
  53 //purpose  :
  54 //=======================================================================
  55 bool SALOME_EvalSet::createValue(const SALOME_String& str, SALOME_EvalVariant& val) const
  56 {
  57   val=str;
  58   return false;
  59 }
  60 //=======================================================================
  61 //function : SALOME_EvalSet::contains
  62 //purpose  :
  63 //=======================================================================
  64 bool SALOME_EvalSet::contains( const SALOME_ListOfEvalSet& aL, const SALOME_EvalSet* pS)
  65 {
  66   bool bRet;
  67   //
  68   bRet=false;
  69   SALOME_ListOfEvalSet::const_iterator aIt=aL.begin();
  70   for(; aIt!=aL.end(); ++aIt) {
  71     const SALOME_EvalSet* pSx=*aIt;
  72     bRet=pSx==pS;
  73     if (bRet) {
  74       break;
  75     }
  76   }
  77   return bRet;
  78 }
  79 //=======================================================================
  80 //function : SALOME_EvalSet::insert
  81 //purpose  :
  82 //=======================================================================
  83 void SALOME_EvalSet::insert(SALOME_ListOfEvalSet& aL, const int aIndex, SALOME_EvalSet* pS)
  84 {
  85   int i;
  86   //
  87   if (!aIndex) {
  88     aL.push_front(pS);
  89   }
  90   else if (aIndex==aL.size()) {
  91     aL.push_back(pS);
  92   }
  93   else {
  94     SALOME_ListOfEvalSet::iterator aIt=aL.begin();
  95     for(i=0; aIt!=aL.end(); ++aIt, ++i) {
  96       //const SALOME_EvalSet* pSx=*aIt;
  97       if (i==aIndex) {
  98         aL.insert( aIt, pS );
  99         break;
 100       }
 101     }
 102   }
 103 }
 104 ///////////////////////////////////
 105 //=======================================================================
 106 //function : SALOME_EvalSetBase
 107 //purpose  :
 108 //=======================================================================
 109 SALOME_EvalSetBase::SALOME_EvalSetBase()
 110 {
 111 }
 112 //=======================================================================
 113 //function : ~SALOME_EvalSetBase
 114 //purpose  :
 115 //=======================================================================
 116 SALOME_EvalSetBase::~SALOME_EvalSetBase()
 117 {
 118 }
 119 //=======================================================================
 120 //function : SALOME_EvalSetBase::operationList
 121 //purpose  :
 122 //=======================================================================
 123 void SALOME_EvalSetBase::operationList( SALOME_StringList& aList ) const
 124 {
 125   SALOME_StringList::const_iterator aIt;
 126   //
 127   aIt=myOpers.begin();
 128   for (; aIt!=myOpers.end(); ++aIt) {
 129     aList.push_back(*aIt);
 130   }
 131 }
 132 //=======================================================================
 133 //function : SALOME_EvalSetBase::bracketsList
 134 //purpose  :
 135 //=======================================================================
 136 void SALOME_EvalSetBase::bracketsList(SALOME_StringList& aList,
 137                                   bool bOpen) const
 138 {
 139   aList.push_back( bOpen ? "(" : ")" );
 140 }
 141 //=======================================================================
 142 //function : SALOME_EvalSetBase::addOperations
 143 //purpose  :
 144 //=======================================================================
 145 void SALOME_EvalSetBase::addOperations(const SALOME_StringList& aList)
 146 {
 147   SALOME_StringList::const_iterator aIt;
 148   SALOME_StringSet aSet;
 149   SALOME_SetPair aSetPair;
 150   //
 151   aIt=aList.begin();
 152   for (; aIt != aList.end(); ++aIt)
 153   {
 154     aSetPair=aSet.insert(*aIt);
 155     if(aSetPair.second) {
 156       myOpers.push_back( *aIt );
 157     }
 158   }
 159 }
 160 //=======================================================================
 161 //function : SALOME_EvalSetBase::addTypes
 162 //purpose  :
 163 //=======================================================================
 164 void SALOME_EvalSetBase::addTypes(const SALOME_ListOfEvalVariantType& aList)
 165 {
 166   SALOME_ListOfEvalVariantType::const_iterator aIt;
 167   SALOME_SetOfEvalVariantType aSet;
 168   SALOME_SetPairOfEvalVariantType aSetPair;
 169   //
 170   aIt=aList.begin();
 171   for (; aIt != aList.end(); ++aIt )  {
 172     aSetPair=aSet.insert(*aIt);
 173     if(aSetPair.second) {
 174       myTypes.push_back(*aIt);
 175     }
 176   }
 177 }
 178 //=======================================================================
 179 //function : SALOME_EvalSetBase::isValid
 180 //purpose  :
 181 //=======================================================================
 182 SALOME_EvalExprError SALOME_EvalSetBase::isValid( const SALOME_String& op,
 183                                                   const SALOME_EvalVariantType t1,
 184                                                   const SALOME_EvalVariantType t2 ) const
 185 {
 186   bool bContainsT1, bContainsT2;
 187   SALOME_SetOfEvalVariantType aSet;
 188   SALOME_SetPairOfEvalVariantType aSetPair;
 189   SALOME_ListOfEvalVariantType::const_iterator aIt;
 190   SALOME_EvalVariantType aType;
 191   //
 192   aIt=myTypes.begin();
 193   for (; aIt != myTypes.end(); ++aIt )  {
 194     aType=*aIt;
 195     aSet.insert(aType);
 196   }
 197   //
 198   aSetPair=aSet.insert(t1);
 199   bContainsT1=!aSetPair.second;
 200   //
 201   aSetPair=aSet.insert(t2);
 202   bContainsT2=!aSetPair.second;
 203   //
 204   if ( ( t1 == SALOME_EvalVariant_Invalid || bContainsT1 ) &&
 205        ( t2 == SALOME_EvalVariant_Invalid || bContainsT2 ) &&
 206        ( t1 != SALOME_EvalVariant_Invalid || t2 != SALOME_EvalVariant_Invalid ) ) {
 207     if ( priority( op, t1 != SALOME_EvalVariant_Invalid && t2 != SALOME_EvalVariant_Invalid ) > 0 ) {
 208       return EvalExpr_OK;
 209     }
 210     else {
 211       return EvalExpr_InvalidOperation;
 212     }
 213   }
 214   return EvalExpr_OperandsNotMatch;
 215 }
 216 ////////////////////////////////////////////////////////////////////////
 217 //=======================================================================
 218 //function : SALOME_EvalSetArithmetic::SALOME_EvalSetArithmetic
 219 //purpose  :
 220 //=======================================================================
 221 SALOME_EvalSetArithmetic::SALOME_EvalSetArithmetic()
 222 : SALOME_EvalSetBase()
 223 {
 224   SALOME_String aOp;
 225   SALOME_StringList aStringList;
 226   SALOME_ListOfEvalVariantType aTypes;
 227   //
 228   aOp="+";  aStringList.push_back(aOp);
 229   aOp="-";  aStringList.push_back(aOp);
 230   aOp="*";  aStringList.push_back(aOp);
 231   aOp="/";  aStringList.push_back(aOp);
 232   aOp="=";  aStringList.push_back(aOp);
 233   aOp="<";  aStringList.push_back(aOp);
 234   aOp=">";  aStringList.push_back(aOp);
 235   aOp="<=";  aStringList.push_back(aOp);
 236   aOp=">=";  aStringList.push_back(aOp);
 237   aOp="<>";  aStringList.push_back(aOp);
 238   aOp="!=";  aStringList.push_back(aOp);
 239   addOperations( aStringList );
 240   //
 241   aTypes.push_back( SALOME_EvalVariant_Int );
 242   aTypes.push_back( SALOME_EvalVariant_UInt );
 243   aTypes.push_back( SALOME_EvalVariant_Double );
 244   addTypes(aTypes);
 245 }
 246 //=======================================================================
 247 //function : SALOME_EvalSetArithmetic::~SALOME_EvalSetArithmetic
 248 //purpose  :
 249 //=======================================================================
 250 SALOME_EvalSetArithmetic::~SALOME_EvalSetArithmetic()
 251 {
 252 }
 253 //=======================================================================
 254 //function : SALOME_EvalSetArithmetic::Name
 255 //purpose  :
 256 //=======================================================================
 257 SALOME_String SALOME_EvalSetArithmetic::Name()
 258 {
 259   return "Arithmetic";
 260 }
 261 //=======================================================================
 262 //function : SALOME_EvalSetArithmetic::name
 263 //purpose  :
 264 //=======================================================================
 265 SALOME_String SALOME_EvalSetArithmetic::name()const
 266 {
 267   return Name();
 268 }
 269 //=======================================================================
 270 //function : SALOME_EvalSetArithmetic::createValue
 271 //purpose  :
 272 //=======================================================================
 273 bool SALOME_EvalSetArithmetic::createValue(const SALOME_String& str,
 274                                        SALOME_EvalVariant& val ) const
 275 {
 276   bool ok;
 277   int iX;
 278   double dX;
 279   //
 280   ok = false;
 281
 282   iX=toInt(str, &ok );
 283   if (ok) {
 284     SALOME_EvalVariant aRV(iX);
 285     val=aRV;
 286     return ok;
 287   }
 288   //
 289   dX=toDouble(str, &ok );
 290   if (ok) {
 291     SALOME_EvalVariant aRV(dX);
 292     val=aRV;
 293     return ok;
 294   }
 295   //
 296   ok = SALOME_EvalSetBase::createValue( str, val );
 297   return ok;
 298 }
 299 //=======================================================================
 300 //function : SALOME_EvalSetArithmetic::priority
 301 //purpose  :
 302 //=======================================================================
 303 int SALOME_EvalSetArithmetic::priority(const SALOME_String& op, bool isBin) const
 304 {
 305   if ( isBin )
 306   {
 307     if ( op == "<" || op == ">" || op == "=" ||
 308          op == "<=" || op == ">=" || op == "<>" || op == "!=" )
 309       return 1;
 310     else if ( op == "+" || op == "-" )
 311       return 2;
 312     else if( op == "*" || op == "/" )
 313       return 3;
 314     else
 315       return 0;
 316   }
 317   else if ( op == "+" || op == "-" )
 318     return 5;
 319   else
 320     return 0;
 321 }
 322 //=======================================================================
 323 //function : SALOME_EvalSetArithmetic::calculate
 324 //purpose  :
 325 //=======================================================================
 326 SALOME_EvalExprError SALOME_EvalSetArithmetic::calculate(const SALOME_String& op,
 327                                                   SALOME_EvalVariant& v1,
 328                                                   SALOME_EvalVariant& v2 ) const
 329 {
 330   bool bValid1, bValid2, bOk;
 331   SALOME_EvalExprError err;
 332   SALOME_EvalVariantType aType1, aType2;
 333   //
 334   err = EvalExpr_OK;
 335   //
 336   bValid1=v1.isValid();
 337   bValid2=v2.isValid();
 338   aType1=v1.type();
 339   aType2=v2.type();
 340
 341   if ( bValid1 && bValid2 ) {// binary operations
 342     if ( ( aType1 == SALOME_EvalVariant_Int || aType1 == SALOME_EvalVariant_UInt ) &&
 343          ( aType2 == SALOME_EvalVariant_Int || aType2 == SALOME_EvalVariant_UInt ) )  {
 344       int _v1, _v2;
 345       //
 346       _v1 = v1.toInt(&bOk);
 347       _v2 = v2.toInt(&bOk);
 348
 349       if ( op == "+" ) {
 350         v1 = _v1 + _v2;
 351       }
 352       else if ( op == "-" ){
 353         v1 = _v1 - _v2;
 354       }
 355       else if ( op == "*" ){
 356         v1 = _v1 * _v2;
 357         }
 358       else if ( op == "/" ) {
 359         if ( _v2 != 0 ) {
 360           if ( _v1 % _v2 == 0 ) {
 361             v1 = _v1 / _v2;
 362           }
 363           else {
 364             v1 = double( _v1 ) / double( _v2 );
 365           }
 366         }
 367         else {
 368           err = EvalExpr_InvalidResult;
 369         }
 370       }
 371       else if ( op == "<" ) {
 372         v1 = _v1 < _v2;
 373       }
 374       else if ( op == ">" ){
 375         v1 = _v1 > _v2;
 376       }
 377       else if ( op == "=" ){
 378         v1 = _v1 == _v2;
 379       }
 380       else if ( op == "<=" ){
 381         v1 = _v1 <= _v2;
 382       }
 383       else if ( op == ">=" ){
 384         v1 = _v1 >= _v2;
 385       }
 386       else if ( op == "<>" || op == "!=" ){
 387         v1 = _v1 != _v2;
 388       }
 389     }
 390     else if ( ( aType1 == SALOME_EvalVariant_Int || aType1 == SALOME_EvalVariant_Double ) &&
 391               ( aType2 == SALOME_EvalVariant_Int || aType2 == SALOME_EvalVariant_Double ) )   {
 392       double _v1 = v1.toDouble(&bOk);
 393       double _v2 = v2.toDouble(&bOk);
 394
 395       if ( op == "+" ) {
 396         v1 = _v1 + _v2;
 397       }
 398       else if ( op == "-" ){
 399         v1 = _v1 - _v2;
 400       }
 401       else if ( op == "*" ){
 402           v1 = _v1 * _v2;
 403       }
 404       else if ( op == "/" ) {
 405         if ( _v2 != 0 ){
 406           v1 = _v1 / _v2;
 407         }
 408         else{
 409           err = EvalExpr_InvalidResult;
 410         }
 411       }
 412       else if ( op == "<" ){
 413         v1 = _v1 < _v2;
 414       }
 415       else if ( op == ">" ){
 416         v1 = _v1 > _v2;
 417       }
 418       else if ( op == "=" ){
 419         v1 = _v1 == _v2;
 420       }
 421       else if ( op == "<=" ){
 422         v1 = _v1 <= _v2;
 423       }
 424       else if ( op == ">=" ){
 425         v1 = _v1 >= _v2;
 426       }
 427       else if ( op == "<>" || op == "!=" ){
 428         v1 = _v1 != _v2;
 429       }
 430     }
 431   }
 432
 433   else {// prefix operations
 434     if ( op == "-" ) {
 435       if ( aType2 == SALOME_EvalVariant_Int ){
 436         v2 = -v2.toInt(&bOk);
 437       }
 438       else if ( aType2 == SALOME_EvalVariant_Double ){
 439         v2 = -v2.toDouble(&bOk);
 440       }
 441     }
 442   }
 443   return err;
 444 }
 445 /////////////////////////////////////////////////////////////////////////
 446 //=======================================================================
 447 //function : SALOME_EvalSetLogic::SALOME_EvalSetLogic
 448 //purpose  :
 449 //=======================================================================
 450 SALOME_EvalSetLogic::SALOME_EvalSetLogic()
 451 : SALOME_EvalSetBase()
 452 {
 453   SALOME_String aOp;
 454   SALOME_StringList aStringList;
 455   SALOME_ListOfEvalVariantType aTypes;
 456   //
 457   aOp="and"; aStringList.push_back(aOp);
 458   aOp="&&";  aStringList.push_back(aOp);
 459   aOp="or";  aStringList.push_back(aOp);
 460   aOp="||";  aStringList.push_back(aOp);
 461   aOp="xor"; aStringList.push_back(aOp);
 462   aOp="not"; aStringList.push_back(aOp);
 463   aOp="!";   aStringList.push_back(aOp);
 464   aOp="imp"; aStringList.push_back(aOp);
 465   aOp="=";   aStringList.push_back(aOp);
 466   addOperations( aStringList );
 467   //
 468   aTypes.push_back( SALOME_EvalVariant_Boolean );
 469   aTypes.push_back( SALOME_EvalVariant_Int );
 470   aTypes.push_back( SALOME_EvalVariant_UInt );
 471   addTypes( aTypes );
 472 }
 473 //=======================================================================
 474 //function : SALOME_EvalSetLogic::~SALOME_EvalSetLogic
 475 //purpose  :
 476 //=======================================================================
 477 SALOME_EvalSetLogic::~SALOME_EvalSetLogic()
 478 {
 479 }
 480 //=======================================================================
 481 //function : SALOME_EvalSetLogic::Name
 482 //purpose  :
 483 //=======================================================================
 484 SALOME_String SALOME_EvalSetLogic::Name()
 485 {
 486   return "Logic";
 487 }
 488 //=======================================================================
 489 //function : SALOME_EvalSetLogic::name
 490 //purpose  :
 491 //=======================================================================
 492 SALOME_String SALOME_EvalSetLogic::name() const
 493 {
 494   return Name();
 495 }
 496 //=======================================================================
 497 //function : SALOME_EvalSetLogic::createValue
 498 //purpose  :
 499 //=======================================================================
 500 bool SALOME_EvalSetLogic::createValue(const SALOME_String& str, SALOME_EvalVariant& val)const
 501 {
 502   bool ok = true;
 503   SALOME_String valStr = toLower(str);
 504   //
 505   if ( valStr == "true" || valStr == "yes" )
 506     val = SALOME_EvalVariant( true );
 507   else if ( valStr == "false" || valStr == "no" )
 508     val = SALOME_EvalVariant( false );
 509   else
 510     ok = SALOME_EvalSetBase::createValue( str, val );
 511   //
 512   return ok;
 513 }
 514 //=======================================================================
 515 //function : SALOME_EvalSetLogic::priority
 516 //purpose  :
 517 //=======================================================================
 518 int SALOME_EvalSetLogic::priority(const SALOME_String& op, bool isBin) const
 519 {
 520   if ( isBin )
 521   {
 522     if ( op == "and" ||
 523          op == "or" ||
 524          op == "xor" ||
 525          op == "&&" ||
 526          op == "||" ||
 527          op == "imp" )
 528       return 1;
 529     else if ( op == "=" )
 530       return 2;
 531     else
 532       return 0;
 533   }
 534   else if ( op == "not" || op == "!" )
 535     return 5;
 536   else
 537     return 0;
 538 }
 539 //=======================================================================
 540 //function : SALOME_EvalSetLogic::priority
 541 //purpose  :
 542 //=======================================================================
 543 SALOME_EvalExprError SALOME_EvalSetLogic::calculate(const SALOME_String& op, SALOME_EvalVariant& v1, SALOME_EvalVariant& v2 ) const
 544 {
 545   SALOME_EvalExprError err = EvalExpr_OK;
 546   //
 547   int val1 = intValue( v1 );
 548   int val2 = intValue( v2 );
 549   if ( v1.isValid() && v2.isValid() )  {
 550     if ( op == "and" || op == "&&" ) {
 551       v1 = val1 && val2;
 552     }
 553     else if ( op == "or" || op == "||" ){
 554       v1 = val1 || val2;
 555     }
 556     else if ( op == "xor" ){
 557       v1 = ( !val1 && val2 ) || ( val1 && !val2 );
 558     }
 559     else if ( op == "imp" ){
 560       v1 = !val1 || val2;
 561     }
 562     else if ( op == "=" ){
 563       v1 = val1 == val2;
 564     }
 565   }
 566   else if ( op == "not" || op == "!" ){
 567     v2 = !val2;
 568   }
 569   //
 570   return err;
 571 }
 572 //=======================================================================
 573 //function : SALOME_EvalSetLogic::intValue
 574 //purpose  :
 575 //=======================================================================
 576 int SALOME_EvalSetLogic::intValue(const SALOME_EvalVariant& v) const
 577 {
 578   bool bOk;
 579   int res = 0;
 580   switch ( v.type() )
 581   {
 582   case SALOME_EvalVariant_Boolean:
 583     res = v.toBool() ? 1 : 0;
 584     break;
 585   case SALOME_EvalVariant_Int:
 586   case SALOME_EvalVariant_UInt:
 587     res = v.toInt(&bOk);
 588     break;
 589   default:
 590     break;
 591   }
 592   return res;
 593 }
 594 /////////////////////////////////////////////////////////////////////////
 595 //=======================================================================
 596 //function : SALOME_EvalSetMath::SALOME_EvalSetMath
 597 //purpose  :
 598 //=======================================================================
 599 SALOME_EvalSetMath::SALOME_EvalSetMath()
 600 : SALOME_EvalSetBase()
 601 {
 602   SALOME_String aOp;
 603   SALOME_StringList aStringList;
 604   SALOME_ListOfEvalVariantType aTypes;
 605   //
 606   aOp="sqrt";  aStringList.push_back(aOp);
 607   aOp="abs";  aStringList.push_back(aOp);
 608   aOp="sin";  aStringList.push_back(aOp);
 609   aOp="cos";  aStringList.push_back(aOp);
 610   aOp="rad2grad";  aStringList.push_back(aOp);
 611   aOp="grad2rad";  aStringList.push_back(aOp);
 612   addOperations( aStringList );
 613   //
 614   aTypes.push_back( SALOME_EvalVariant_Int );
 615   aTypes.push_back( SALOME_EvalVariant_Double );
 616   addTypes( aTypes );
 617 }
 618 //=======================================================================
 619 //function : SALOME_EvalSetMath::~SALOME_EvalSetMath
 620 //purpose  :
 621 //=======================================================================
 622 SALOME_EvalSetMath::~SALOME_EvalSetMath()
 623 {
 624 }
 625 //=======================================================================
 626 //function : SALOME_EvalSetMath::Name
 627 //purpose  :
 628 //=======================================================================
 629 SALOME_String SALOME_EvalSetMath::Name()
 630 {
 631   return "Math";
 632 }
 633 //=======================================================================
 634 //function : SALOME_EvalSetMath::name
 635 //purpose  :
 636 //=======================================================================
 637 SALOME_String SALOME_EvalSetMath::name() const
 638 {
 639   return Name();
 640 }
 641 //=======================================================================
 642 //function : SALOME_EvalSetMath::createValue
 643 //purpose  :
 644 //=======================================================================
 645 bool SALOME_EvalSetMath::createValue(const SALOME_String& str, SALOME_EvalVariant& val) const
 646 {
 647   bool ok = false;
 648   //
 649   val=toInt(str, &ok);
 650   if (!ok) {
 651     val=toDouble(str, &ok);
 652     if (!ok) {
 653       ok = SALOME_EvalSetBase::createValue(str, val);
 654     }
 655   }
 656   return ok;
 657 }
 658 //=======================================================================
 659 //function : SALOME_EvalSetMath::priority
 660 //purpose  :
 661 //=======================================================================
 662 int SALOME_EvalSetMath::priority(const SALOME_String& op, bool isBin) const
 663 {
 664   if ( isBin ){
 665     return 0;
 666   }
 667   else if ( op == "sqrt" ||
 668             op == "abs" ||
 669             op == "sin" ||
 670             op == "cos" ||
 671             op == "rad2grad"
 672             || op == "grad2rad" ){
 673     return 1;
 674   }
 675   return 0;
 676 }
 677 //=======================================================================
 678 //function : SALOME_EvalSetMath::calculate
 679 //purpose  :
 680 //=======================================================================
 681 SALOME_EvalExprError SALOME_EvalSetMath::calculate(const SALOME_String& op, SALOME_EvalVariant& v1, SALOME_EvalVariant& v2 ) const
 682 {
 683   bool bOk;
 684   SALOME_EvalExprError err = EvalExpr_OK;
 685
 686   double val = v2.toDouble(&bOk);
 687   if ( op == "sqrt" ) {
 688     if ( val >= 0 ) {
 689       v2 = sqrt( val );
 690     }
 691     else {
 692       err = EvalExpr_InvalidResult;
 693     }
 694   }
 695   else if ( op == "abs" )  {
 696     if ( v2.type() == SALOME_EvalVariant_Int ) {
 697       v2 = abs( v2.toInt(&bOk) );
 698     }
 699     else {
 700       v2 = fabs( v2.toDouble(&bOk) );
 701     }
 702   }
 703   //
 704   else if ( op == "sin" ) {
 705     v2 = sin( val );
 706   }
 707   else if ( op == "cos" ) {
 708     v2 = cos( val );
 709   }
 710   else if ( op == "grad2rad" ){
 711     v2 = val * 3.14159256 / 180.0;
 712   }
 713   else if ( op == "rad2grad" ) {
 714     v2 = val * 180.0 / 3.14159256;
 715   }
 716
 717   return err;
 718 }
 719 /////////////////////////////////////////////////////////////////////////
 720 //=======================================================================
 721 //function : SALOME_EvalSetString::SALOME_EvalSetString
 722 //purpose  :
 723 //=======================================================================
 724 SALOME_EvalSetString::SALOME_EvalSetString()
 725 : SALOME_EvalSetBase()
 726 {
 727   SALOME_String aOp;
 728   SALOME_StringList aStringList;
 729   SALOME_ListOfEvalVariantType aTypes;
 730   //
 731   aOp="+";  aStringList.push_back(aOp);
 732   aOp="=";  aStringList.push_back(aOp);
 733   aOp="<";  aStringList.push_back(aOp);
 734   aOp=">";  aStringList.push_back(aOp);
 735   aOp="<=";  aStringList.push_back(aOp);
 736   aOp=">=";  aStringList.push_back(aOp);
 737   aOp="<>";  aStringList.push_back(aOp);
 738   aOp="!=";  aStringList.push_back(aOp);
 739   aOp="length";  aStringList.push_back(aOp);
 740   aOp="lower";  aStringList.push_back(aOp);
 741   aOp="upper";  aStringList.push_back(aOp);
 742   addOperations( aStringList );
 743
 744   aTypes.push_back( SALOME_EvalVariant_Int );
 745   aTypes.push_back( SALOME_EvalVariant_Double );
 746   aTypes.push_back( SALOME_EvalVariant_String );
 747   addTypes( aTypes );
 748 }
 749 //=======================================================================
 750 //function : SALOME_EvalSetString::~SALOME_EvalSetString
 751 //purpose  :
 752 //=======================================================================
 753 SALOME_EvalSetString::~SALOME_EvalSetString()
 754 {
 755 }
 756 //=======================================================================
 757 //function : SALOME_EvalSetString::Name
 758 //purpose  :
 759 //=======================================================================
 760 SALOME_String SALOME_EvalSetString::Name()
 761 {
 762   return "String";
 763 }
 764 //=======================================================================
 765 //function : SALOME_EvalSetString::name
 766 //purpose  :
 767 //=======================================================================
 768 SALOME_String SALOME_EvalSetString::name()const
 769 {
 770   return Name();
 771 }
 772 //=======================================================================
 773 //function : SALOME_EvalSetString::createValue
 774 //purpose  :
 775 //=======================================================================
 776 bool SALOME_EvalSetString::createValue(const SALOME_String& str, SALOME_EvalVariant& val) const
 777 {
 778   bool ok = false;
 779   const char* myString=str.c_str();
 780   int myLength=(int)strlen(myString);
 781   //
 782   if (myLength > 1 &&
 783       myString[0] == '\'' &&
 784       myString[str.length() - 1] == '\'' )  {
 785     char *pMid;
 786     int i, aNb;
 787     //
 788     aNb=myLength-2;
 789     pMid=new char[aNb+1];
 790     //
 791     for(i=0; i<aNb; ++i) {
 792       pMid[i]=myString[i+1];
 793     }
 794     pMid[aNb]=0;
 795     val=pMid;
 796     //
 797     delete pMid;
 798     //val = str.mid( 1, str.length() - 2 );
 799     ok = true;
 800   }
 801   else {
 802     ok = SALOME_EvalSetBase::createValue( str, val );
 803   }
 804   return ok;
 805 }
 806 //=======================================================================
 807 //function : SALOME_EvalSetString::priority
 808 //purpose  :
 809 //=======================================================================
 810 int SALOME_EvalSetString::priority(const SALOME_String& op, bool isBin) const
 811 {
 812   if ( isBin )  {
 813     if ( op == "+" ) {
 814       return 2;
 815     }
 816     else if ( op == "=" || op == "<" || op == ">" ||
 817       op == "<=" || op == ">=" || op == "<>" || op == "!=" ){
 818       return 1;
 819     }
 820     else{
 821       return 0;
 822     }
 823   }
 824   else if ( op == "length" || op == "lower" || op=="upper" ){
 825     return 5;
 826   }
 827   return 0;
 828 }
 829 //=======================================================================
 830 //function : SALOME_EvalSetString::calculate
 831 //purpose  :
 832 //=======================================================================
 833 SALOME_EvalExprError SALOME_EvalSetString::calculate(const SALOME_String& op, SALOME_EvalVariant& v1, SALOME_EvalVariant& v2) const
 834 {
 835   SALOME_EvalExprError err = EvalExpr_OK;
 836   if ( v1.isValid() && v2.isValid() )
 837   {
 838     SALOME_String _v1 = v1.toString();
 839     SALOME_String _v2 = v2.toString();
 840     if ( op == "+" )
 841       v1 = _v1 + _v2;
 842     else if ( op == "=" )
 843       v1 = _v1 ==_v2;
 844     else if ( op == "<" )
 845       v1 = _v1 < _v2;
 846     else if ( op == ">" )
 847       v1 = _v1 > _v2;
 848     else if ( op == "<>" || op == "!=" )
 849       v1 = _v1 != _v2;
 850     else if ( op == "<=" )
 851       v1 = _v1 < _v2 || _v1 == _v2;
 852     else if ( op == ">=" )
 853       v1 = _v1 > _v2 || _v1 == _v2;
 854   }
 855   else if ( !v1.isValid() && v2.isValid() )
 856   {
 857     SALOME_String val = v2.toString();
 858     if ( op == "length" )
 859       v2 = (int)val.length();
 860     else if ( op == "lower" ) {
 861       v2=toLower(val);
 862     }
 863     else if ( op == "upper" ) {
 864       v2=toUpper(val);
 865     }
 866   }
 867   return err;
 868 }
 869 /////////////////////////////////////////////////////////////////////////
 870 //=======================================================================
 871 //function : SALOME_EvalSetSets::SALOME_EvalSetSets
 872 //purpose  :
 873 //=======================================================================
 874 SALOME_EvalSetSets::SALOME_EvalSetSets()
 875 : SALOME_EvalSetBase()
 876 {
 877   SALOME_String aOp;
 878   SALOME_StringList aStringList;
 879   SALOME_ListOfEvalVariantType aTypes;
 880   //
 881   aOp="{";  aStringList.push_back(aOp);
 882   aOp="}";  aStringList.push_back(aOp);
 883   aOp="<>";  aStringList.push_back(aOp);
 884   aOp="!=";  aStringList.push_back(aOp);
 885   aOp="+";  aStringList.push_back(aOp);
 886   aOp="-";  aStringList.push_back(aOp);
 887   aOp="*";  aStringList.push_back(aOp);
 888   aOp="in";  aStringList.push_back(aOp);
 889   aOp="count";  aStringList.push_back(aOp);
 890   addOperations( aStringList );
 891   //
 892   aTypes.push_back( SALOME_EvalVariant_List );
 893   addTypes( aTypes );
 894 }
 895 //=======================================================================
 896 //function : SALOME_EvalSetSets::~SALOME_EvalSetSets
 897 //purpose  :
 898 //=======================================================================
 899 SALOME_EvalSetSets::~SALOME_EvalSetSets()
 900 {
 901 }
 902 //=======================================================================
 903 //function : SALOME_EvalSetSets::Name
 904 //purpose  :
 905 //=======================================================================
 906 SALOME_String SALOME_EvalSetSets::Name()
 907 {
 908   return "Sets";
 909 }
 910 //=======================================================================
 911 //function : SALOME_EvalSetSets::name
 912 //purpose  :
 913 //=======================================================================
 914 SALOME_String SALOME_EvalSetSets::name()const
 915 {
 916   return Name();
 917 }
 918 //=======================================================================
 919 //function : SALOME_EvalSetSets::bracketsList
 920 //purpose  :
 921 //=======================================================================
 922 void SALOME_EvalSetSets::bracketsList(SALOME_StringList& aList, bool bOpen ) const
 923 {
 924   aList.push_back( bOpen ? "{" : "}" );
 925   SALOME_EvalSetBase::bracketsList(aList, bOpen);
 926 }
 927 //=======================================================================
 928 //function : SALOME_EvalSetSets::bracketsList
 929 //purpose  :
 930 //=======================================================================
 931 int SALOME_EvalSetSets::priority(const SALOME_String& op, bool isBin) const
 932 {
 933   if ( isBin )  {
 934     if ( op == "=" || op == "<>" || op == "!=" )
 935       return 1;
 936     else if ( op == "+" || op == "-" || op == "*" )
 937       return 2;
 938     else if ( op == "in" )
 939       return 3;
 940     else
 941       return 0;
 942   }
 943   else if ( op == "{" || op == "}" )
 944     return 5;
 945   else if ( op == "count" )
 946     return 4;
 947   else
 948     return 0;
 949 }
 950 //=======================================================================
 951 //function : SALOME_EvalSetSets::isValid
 952 //purpose  :
 953 //=======================================================================
 954 SALOME_EvalExprError SALOME_EvalSetSets::isValid(const SALOME_String& op,
 955                                                  const SALOME_EvalVariantType t1,
 956                                                  const SALOME_EvalVariantType t2 ) const
 957 {
 958   if ( op == "{" ) {
 959     return EvalExpr_OK;
 960   }
 961   if ( op != "in" ) {
 962     return SALOME_EvalSetBase::isValid( op, t1, t2 );
 963   }
 964   if ( t1 != SALOME_EvalVariant_Invalid && t2 == SALOME_EvalVariant_List ) {
 965     return EvalExpr_OK;
 966   }
 967   //else
 968   return EvalExpr_OperandsNotMatch;
 969 }
 970 //=======================================================================
 971 //function : SALOME_EvalSetSets::add
 972 //purpose  :
 973 //=======================================================================
 974 void SALOME_EvalSetSets::add(ValueSet& aSet, const SALOME_EvalVariant& v)
 975 {
 976
 977   if ( v.isValid() && !SALOME_EvalVariant::contains( aSet, v ) ) {
 978     aSet.push_back( v );
 979   }
 980 }
 981 //=======================================================================
 982 //function : SALOME_EvalSetSets::add
 983 //purpose  :
 984 //=======================================================================
 985 void SALOME_EvalSetSets::add(ValueSet& s1, const ValueSet& s2)
 986 {
 987   ValueSet::const_iterator anIt = s2.begin();
 988   for ( ; anIt != s2.end(); ++anIt )
 989     add( s1, *anIt );
 990 }
 991 //=======================================================================
 992 //function : SALOME_EvalSetSets::remove
 993 //purpose  :
 994 //=======================================================================
 995 void SALOME_EvalSetSets::remove(ValueSet& aSet, const SALOME_EvalVariant& v)
 996 {
 997   aSet.remove(v);
 998 }
 999 //=======================================================================
1000 //function : SALOME_EvalSetSets::remove
1001 //purpose  :
1002 //=======================================================================
1003 void SALOME_EvalSetSets::remove(ValueSet& s1, const ValueSet& s2)
1004 {
1005   ValueSet::const_iterator aIt = s2.begin();
1006   for (; aIt != s2.end(); ++aIt ) {
1007     s1.remove(*aIt);
1008   }
1009 }
1010 //=======================================================================
1011 //function : SALOME_EvalSetSets::calculate
1012 //purpose  :
1013 //=======================================================================
1014 SALOME_EvalExprError SALOME_EvalSetSets::calculate(const SALOME_String& op,
1015                                                    SALOME_EvalVariant& v1,
1016                                                    SALOME_EvalVariant& v2 ) const
1017 {
1018   SALOME_EvalExprError err = EvalExpr_OK;
1019   // !!!
1020   if ( op != "{" )  {
1021     if ( op == "}" ) {
1022       ValueSet aNewList;
1023       add( aNewList, v1.toList() );
1024       v1 = aNewList;
1025     }
1026     else if (op == "=" || op == "<>" || op == "!=" ||
1027              op == "+" || op == "-" || op == "*" ) {
1028       ValueSet aNewList;
1029       add( aNewList, v1.toList() );
1030       if ( op == "=" || op == "<>" || op == "!=" || op == "-" ) {
1031         remove( aNewList, v2.toList() );
1032         if ( op == "=" ){
1033           v1 = aNewList.empty() && v1.toList().size() == v2.toList().size();
1034         }
1035         else if ( op == "<>" || op == "!=" ) {
1036           v1 = !aNewList.empty() || v1.toList().size() != v2.toList().size();
1037         }
1038         else{
1039           v1 = aNewList;
1040         }
1041       }
1042       else if ( op == "+" ) {
1043         add( aNewList, v2.toList() );
1044         v1 = aNewList;
1045       }
1046       else if ( op == "*" ) {
1047         ValueSet toDelete;
1048         add( toDelete, aNewList );
1049         remove( toDelete, v2.toList() );
1050         remove( aNewList, toDelete );
1051         v1 = aNewList;
1052       }
1053     }
1054     else if ( op== "count" ) {
1055       v2 = (int)v2.toList().size();
1056     }
1057     else if ( op == "in" ) {
1058       if ( v1.type() == SALOME_EvalVariant_List ) {
1059         bool res = true;
1060         ValueSet lst1 = v1.toList();
1061         ValueSet lst2 = v2.toList();
1062         ValueSet::const_iterator anIt = lst1.begin();
1063         for (; anIt != lst1.end() && res; ++anIt ){
1064           res = SALOME_EvalVariant::contains(lst2, *anIt );
1065         }
1066         v1 = res;
1067       }
1068       else {
1069         SALOME_ListOfEvalVariant aL=v2.toList();
1070         bool bContains=SALOME_EvalVariant::contains(aL, v1);
1071         v1=SALOME_EvalVariant(bContains);
1072       }
1073     }
1074   }
1075
1076   return err;
1077 }
1078 /////////////////////////////////////////////////////////////////////////
1079 //=======================================================================
1080 //function : SALOME_EvalSetConst::SALOME_EvalSetConst
1081 //purpose  :
1082 //=======================================================================
1083 SALOME_EvalSetConst::SALOME_EvalSetConst()
1084 : SALOME_EvalSet()
1085 {
1086 }
1087 //=======================================================================
1088 //function : SALOME_EvalSetConst::~SALOME_EvalSetConst
1089 //purpose  :
1090 //=======================================================================
1091 SALOME_EvalSetConst::~SALOME_EvalSetConst()
1092 {
1093 }
1094 //=======================================================================
1095 //function : SALOME_EvalSetConst::Name
1096 //purpose  :
1097 //=======================================================================
1098 SALOME_String SALOME_EvalSetConst::Name()
1099 {
1100   return "Const";
1101 }
1102 //=======================================================================
1103 //function : SALOME_EvalSetConst::name
1104 //purpose  :
1105 //=======================================================================
1106 SALOME_String SALOME_EvalSetConst::name() const
1107 {
1108   return Name();
1109 }
1110 //=======================================================================
1111 //function : SALOME_EvalSetConst::createValue
1112 //purpose  :
1113 //=======================================================================
1114 bool SALOME_EvalSetConst::createValue(const SALOME_String& str, SALOME_EvalVariant& val) const
1115 {
1116   bool ok = true;
1117   if ( str == "pi" )            // PI number
1118     val = SALOME_EvalVariant( 3.141593 );
1119   else if ( str == "exp" )      // Exponent value (e)
1120     val = SALOME_EvalVariant( 2.718282 );
1121   else if ( str == "g" )        // Free fall acceleration (g)
1122     val = SALOME_EvalVariant( 9.80665 );
1123   else
1124     ok = false;
1125
1126   return ok;
1127 }
1128 //=======================================================================
1129 //function : SALOME_EvalSetConst::operationList
1130 //purpose  :
1131 //=======================================================================
1132 void SALOME_EvalSetConst::operationList(SALOME_StringList&) const
1133 {
1134 }
1135 //=======================================================================
1136 //function : SALOME_EvalSetConst::bracketsList
1137 //purpose  :
1138 //=======================================================================
1139 void SALOME_EvalSetConst::bracketsList(SALOME_StringList& , bool) const
1140 {
1141 }
1142 //=======================================================================
1143 //function : SALOME_EvalSetConst::priority
1144 //purpose  :
1145 //=======================================================================
1146 int SALOME_EvalSetConst::priority(const SALOME_String& /*op*/, bool /*isBin*/ ) const
1147 {
1148   return 0;
1149 }
1150 //=======================================================================
1151 //function : SALOME_EvalSetConst::isValid
1152 //purpose  :
1153 //=======================================================================
1154 SALOME_EvalExprError SALOME_EvalSetConst::isValid(const SALOME_String& /*op*/,
1155                                                   const SALOME_EvalVariantType /*t1*/,
1156                                                   const SALOME_EvalVariantType /*t2*/ ) const
1157 {
1158   return EvalExpr_InvalidOperation;
1159 }
1160 //=======================================================================
1161 //function : SALOME_EvalSetConst::calculate
1162 //purpose  :
1163 //=======================================================================
1164 SALOME_EvalExprError SALOME_EvalSetConst::calculate(const SALOME_String&,
1165                                              SALOME_EvalVariant&,
1166                                              SALOME_EvalVariant& ) const
1167 {
1168   return EvalExpr_InvalidOperation;
1169 }
1170
1171 /////////////////////////////////////////////////////////////////////////
1172 //=======================================================================
1173 //function : toUpper
1174 //purpose  :
1175 //=======================================================================
1176 SALOME_String toUpper(const SALOME_String& str)
1177 {
1178   char aC;
1179   const char* mystring=str.c_str();
1180   size_t mylength, i;
1181   SALOME_String aRet;
1182   //
1183   aRet=str;
1184   if(mystring) {
1185     mylength=strlen(mystring);
1186     for (i=0; i < mylength; i++) {
1187       aC=(char)toupper(mystring[i]);
1188       aRet.at(i)=aC;
1189     }
1190   }
1191   return aRet;
1192 }
1193 //=======================================================================
1194 //function : tolower
1195 //purpose  :
1196 //=======================================================================
1197 SALOME_String toLower(const SALOME_String& str)
1198 {
1199   char aC;
1200   const char* mystring=str.c_str();
1201   size_t mylength, i;
1202   SALOME_String aRet;
1203   //
1204   aRet=str;
1205   if(mystring) {
1206     mylength=strlen(mystring);
1207     for (i=0; i < mylength; i++) {
1208       aC=(char)tolower(mystring[i]);
1209       aRet.at(i)=aC;
1210     }
1211   }
1212   return aRet;
1213 }
1214 //=======================================================================
1215 //function : toDouble
1216 //purpose  :
1217 //=======================================================================
1218 double toDouble(const SALOME_String& str, bool *ok)
1219 {
1220   char *ptr;
1221   const char* mystring=str.c_str();
1222   double value;
1223   //
1224   value=0.;
1225   *ok=false;
1226   if(mystring) {
1227     value=strtod(mystring,&ptr);
1228     if (ptr != mystring) {
1229       *ok=true;
1230       return value;
1231     }
1232     else{
1233       value=0.;
1234     }
1235   }
1236   return value;
1237 }
1238 //=======================================================================
1239 //function : toInt
1240 //purpose  :
1241 //=======================================================================
1242 int toInt(const SALOME_String& str, bool *ok)
1243 {
1244   char *ptr;
1245   const char* mystring=str.c_str();
1246   size_t mylength, i;
1247   int value;
1248   //
1249   value=0;
1250   *ok=false;
1251   if(mystring) {
1252     mylength=strlen(mystring);
1253     value = (int)strtol(mystring, &ptr,10);
1254     //
1255     if (ptr != mystring) {
1256       for (i=0; i < mylength; i++) {
1257         if (mystring[i] == '.') {
1258           value=0;
1259           return value;
1260         }
1261       }
1262       *ok=true;
1263       return value;
1264     }
1265   }
1266   return value;
1267 }