src/Notebook/SALOME_EvalVariant.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_EvalVariant.cxx
  23 //  Author : Peter KURNEV
  24 //  Module : SALOME
  25
  26 #include <SALOME_EvalVariant.hxx>
  27
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30
  31 //=======================================================================
  32 //function : SALOME_EvalVariantData
  33 //purpose  :
  34 //=======================================================================
  35 SALOME_EvalVariantData::SALOME_EvalVariantData(const SALOME_EvalVariantData& other)
  36 {
  37   myType=other.myType;
  38   myValue.myPtr=NULL;
  39   //
  40   switch (myType) {
  41     case SALOME_EvalVariant_String: {
  42       RString& aStr=*(RString *)(other.myValue.myPtr);
  43       RString *pStr=new RString(aStr);
  44       myValue.myPtr=(void*)pStr;
  45     }
  46       break;
  47
  48     case SALOME_EvalVariant_List: {
  49       SALOME_ListOfEvalVariant& aX=*(SALOME_ListOfEvalVariant*)(other.myValue.myPtr);
  50       SALOME_ListOfEvalVariant *p=new SALOME_ListOfEvalVariant(aX);
  51       myValue.myPtr=(void*)p;
  52     }
  53       break;
  54
  55     default:
  56       myValue=other.myValue;
  57       break;
  58   }
  59 }
  60 //=======================================================================
  61 //function : operator=
  62 //purpose  :
  63 //=======================================================================
  64 SALOME_EvalVariantData& SALOME_EvalVariantData::operator=(const SALOME_EvalVariantData& other)
  65 {
  66   clear();
  67   myType=other.myType;
  68   switch (myType) {
  69     case SALOME_EvalVariant_String: {
  70       RString& aStr=*(string *)(other.myValue.myPtr);
  71       RString *pStr=new RString(aStr);
  72       myValue.myPtr=(void*)pStr;
  73     }
  74       break;
  75
  76     case SALOME_EvalVariant_List: {
  77       SALOME_ListOfEvalVariant& aX=*(SALOME_ListOfEvalVariant*)(other.myValue.myPtr);
  78       SALOME_ListOfEvalVariant *p=new SALOME_ListOfEvalVariant(aX);
  79       myValue.myPtr=(void*)p;
  80     }
  81       break;
  82
  83     default:
  84       myValue=other.myValue;
  85       break;
  86   }
  87   return *this;
  88 }
  89 //=======================================================================
  90 //function : operator==
  91 //purpose  :
  92 //=======================================================================
  93 bool SALOME_EvalVariantData::operator==(const SALOME_EvalVariantData& theOther) const
  94 {
  95   bool bRet;
  96   //
  97   bRet=myType==SALOME_EvalVariant_Invalid || theOther.myType==SALOME_EvalVariant_Invalid;
  98   if (!bRet) {
  99     return bRet;
 100   }
 101   //
 102   bRet=myType==theOther.myType;
 103   if (!bRet) {
 104     return bRet;
 105   }
 106   //
 107   switch (myType) {
 108     case SALOME_EvalVariant_Boolean:
 109       bRet=myValue.myBoolean==theOther.myValue.myBoolean;
 110       break;
 111     //
 112     case SALOME_EvalVariant_Int:
 113       bRet=myValue.myInt==theOther.myValue.myInt;
 114       break;
 115     //
 116     case SALOME_EvalVariant_UInt:
 117       bRet=myValue.myUInt==theOther.myValue.myUInt;
 118       break;
 119     //
 120     case SALOME_EvalVariant_Double:
 121       bRet=myValue.myDouble==theOther.myValue.myDouble;
 122       break;
 123     //
 124     case SALOME_EvalVariant_String: {
 125       bool bIsNull, bIsNullOther;
 126       //
 127       bIsNull=!myValue.myPtr;
 128       bIsNullOther=!theOther.myValue.myPtr;
 129       if (bIsNull && bIsNullOther) {
 130           bRet=true;
 131       }
 132       else if (bIsNull && !bIsNullOther) {
 133         bRet=false;
 134       }
 135       else if (!bIsNull && bIsNullOther) {
 136         bRet=false;
 137       }
 138       else {
 139         RString& myStr=*(RString *)(myValue.myPtr);
 140         RString& aOther=*(RString *)(theOther.myValue.myPtr);
 141         bRet=myStr==aOther;
 142       }
 143     }
 144       break;
 145     //
 146     case SALOME_EvalVariant_List: {
 147       bool bIsNull, bIsNullOther;
 148       //
 149       bIsNull=!myValue.myPtr;
 150       bIsNullOther=!theOther.myValue.myPtr;
 151       if (bIsNull && bIsNullOther) {
 152           bRet=true;
 153       }
 154       else if (bIsNull && !bIsNullOther) {
 155         bRet=false;
 156       }
 157       else if (!bIsNull && bIsNullOther) {
 158         bRet=false;
 159       }
 160       else {
 161         size_t aNb1, aNb2;
 162         //
 163         const SALOME_ListOfEvalVariant& aL1=*(SALOME_ListOfEvalVariant*)(myValue.myPtr);
 164         const SALOME_ListOfEvalVariant& aL2=*(SALOME_ListOfEvalVariant*)(theOther.myValue.myPtr);
 165         aNb1=aL1.size();
 166         aNb2=aL2.size();
 167         bRet=aNb1==aNb2;
 168         if (!bRet) {
 169           break;
 170         }
 171         //
 172         SALOME_ListOfEvalVariant::const_iterator aIt1 = aL1.begin();
 173         SALOME_ListOfEvalVariant::const_iterator aIt2 = aL2.begin();
 174         for ( ; aIt1 != aL1.end(); ++aIt1, ++aIt2 ) {
 175           const SALOME_EvalVariant& aV1=*aIt1;
 176           const SALOME_EvalVariant& aV2=*aIt2;
 177           const SALOME_EvalVariantData& aD1=aV1.Data();
 178           const SALOME_EvalVariantData& aD2=aV2.Data();
 179           bRet=aD1==aD2;
 180           if (!bRet) {
 181             break;
 182           }
 183         }
 184       }
 185     }
 186       break;
 187
 188     default:
 189       bRet=false;
 190       break;
 191   }
 192   return bRet;
 193 }
 194 /////////////////////////////////////////////////////////////////////////
 195 //
 196 // class: SALOME_EvalVariant
 197 //
 198
 199
 200 //=======================================================================
 201 //function : SALOME_EvalVariant
 202 //purpose  :
 203 //=======================================================================
 204 SALOME_EvalVariant::SALOME_EvalVariant(bool theValue)
 205 {
 206   ChangeDataType()=SALOME_EvalVariant_Boolean;
 207   ChangeDataValue().myBoolean=theValue;
 208 }
 209 //=======================================================================
 210 //function : SALOME_EvalVariant
 211 //purpose  :
 212 //=======================================================================
 213 SALOME_EvalVariant::SALOME_EvalVariant(int theValue)
 214 {
 215   ChangeDataType()=SALOME_EvalVariant_Int;
 216   ChangeDataValue().myInt=theValue;
 217 }
 218 //=======================================================================
 219 //function : SALOME_EvalVariant
 220 //purpose  :
 221 //=======================================================================
 222 SALOME_EvalVariant::SALOME_EvalVariant(uint theValue)
 223 {
 224   ChangeDataType()=SALOME_EvalVariant_UInt;
 225   ChangeDataValue().myUInt=theValue;
 226 }
 227 //=======================================================================
 228 //function : SALOME_EvalVariant
 229 //purpose  :
 230 //=======================================================================
 231 SALOME_EvalVariant::SALOME_EvalVariant(double theValue)
 232 {
 233   ChangeDataType()=SALOME_EvalVariant_Double;
 234   ChangeDataValue().myDouble=theValue;
 235 }
 236 //=======================================================================
 237 //function : SALOME_EvalVariant
 238 //purpose  :
 239 //=======================================================================
 240 SALOME_EvalVariant::SALOME_EvalVariant(const RString& theValue)
 241 {
 242   ChangeDataType()=SALOME_EvalVariant_String;
 243   RString *p=new RString(theValue);
 244   ChangeDataValue().myPtr=(void*)p;
 245 }
 246 //=======================================================================
 247 //function : SALOME_EvalVariant
 248 //purpose  :
 249 //=======================================================================
 250 SALOME_EvalVariant::SALOME_EvalVariant(const SALOME_ListOfEvalVariant& theValue)
 251 {
 252   ChangeDataType()=SALOME_EvalVariant_List;
 253   SALOME_ListOfEvalVariant *p=new SALOME_ListOfEvalVariant(theValue);
 254   ChangeDataValue().myPtr=(void*)p;
 255 }
 256 //=======================================================================
 257 //function : operator=
 258 //purpose  :
 259 //=======================================================================
 260 void SALOME_EvalVariant::operator=(const RString& theValue)
 261 {
 262   clear();
 263   //
 264   ChangeDataType()=SALOME_EvalVariant_String;
 265   RString *p=new RString(theValue);
 266   ChangeDataValue().myPtr=(void*)p;
 267 }
 268 //=======================================================================
 269 //function : operator=
 270 //purpose  :
 271 //=======================================================================
 272 void SALOME_EvalVariant::operator=(const bool theValue)
 273 {
 274   clear();
 275   //
 276   ChangeDataType()=SALOME_EvalVariant_Boolean;
 277   ChangeDataValueBoolean()=theValue;
 278 }
 279 //=======================================================================
 280 //function : operator=
 281 //purpose  :
 282 //=======================================================================
 283 void SALOME_EvalVariant::operator=(const int theValue)
 284 {
 285   clear();
 286   //
 287   ChangeDataType()=SALOME_EvalVariant_Int;
 288   ChangeDataValueInt()=theValue;
 289 }
 290 //=======================================================================
 291 //function : operator=
 292 //purpose  :
 293 //=======================================================================
 294 void SALOME_EvalVariant::operator=(const uint theValue)
 295 {
 296   clear();
 297   //
 298   ChangeDataType()=SALOME_EvalVariant_UInt;
 299   ChangeDataValueUInt()=theValue;
 300 }
 301 //=======================================================================
 302 //function : operator=
 303 //purpose  :
 304 //=======================================================================
 305 void SALOME_EvalVariant::operator=(const double theValue)
 306 {
 307   clear();
 308   //
 309   ChangeDataType()=SALOME_EvalVariant_Double;
 310   ChangeDataValueDouble()=theValue;
 311 }
 312 //=======================================================================
 313 //function : operator=
 314 //purpose  :
 315 //=======================================================================
 316 void SALOME_EvalVariant::operator=(const char* theValue)
 317 {
 318   clear();
 319   //
 320   ChangeDataType()=SALOME_EvalVariant_String;
 321   RString *p=new RString(theValue);
 322   ChangeDataValue().myPtr=(void*)p;
 323 }
 324 //=======================================================================
 325 //function : toBool
 326 //purpose  :
 327 //=======================================================================
 328 bool SALOME_EvalVariant::toBool() const
 329 {
 330   SALOME_EvalVariantType aType=type();
 331   //
 332   if ( aType == SALOME_EvalVariant_Boolean ) {
 333           return DataValueBoolean();
 334   }
 335   else if ( aType == SALOME_EvalVariant_Int ) {
 336           return DataValueInt() != 0;
 337   }
 338   else if ( aType == SALOME_EvalVariant_UInt ) {
 339           return DataValueUInt() != 0;
 340   }
 341   else if ( aType == SALOME_EvalVariant_Double ) {
 342           return DataValueDouble() != 0.;
 343   }
 344   else if ( aType == SALOME_EvalVariant_String ) {
 345     RString aZero("0"), aFalse("false");
 346     const RString& aStr=DataValueString();
 347     return !(aStr==aZero || aStr==aFalse || aStr.empty());
 348   }
 349   return false;
 350 }
 351 //=======================================================================
 352 //function : toInt
 353 //purpose  :
 354 //=======================================================================
 355 int SALOME_EvalVariant::toInt(bool *ok) const
 356 {
 357   *ok=false;
 358   //
 359   SALOME_EvalVariantType aType=type();
 360   //
 361   if (aType == SALOME_EvalVariant_Boolean ) {
 362           return (int)DataValueBoolean();
 363   }
 364   else if (aType == SALOME_EvalVariant_Int ) {
 365           return DataValueInt();
 366   }
 367   else if (aType == SALOME_EvalVariant_UInt ) {
 368           return (int)DataValueUInt();
 369   }
 370   else if (aType == SALOME_EvalVariant_Double ) {
 371           return (int)DataValueDouble();
 372   }
 373   else if (aType == SALOME_EvalVariant_String) {
 374     int iRet;
 375     //
 376     const RString& aStr=DataValueString();
 377     const char *pStr=aStr.c_str();
 378     iRet=atoi(pStr);
 379     return iRet;
 380   }
 381   return 0;
 382 }
 383 //=======================================================================
 384 //function : toUInt
 385 //purpose  :
 386 //=======================================================================
 387 uint SALOME_EvalVariant::toUInt(bool *ok) const
 388 {
 389   int iX;
 390   //
 391   iX=toInt(ok);
 392   //
 393   return (uint)iX;
 394 }
 395 //=======================================================================
 396 //function : toDouble
 397 //purpose  :
 398 //=======================================================================
 399 double SALOME_EvalVariant::toDouble(bool *ok) const
 400 {
 401   *ok=false;
 402   //
 403   SALOME_EvalVariantType aType=type();
 404   //
 405   if (aType == SALOME_EvalVariant_Boolean ) {
 406           return (double)DataValueBoolean();
 407   }
 408   else if (aType == SALOME_EvalVariant_Int ) {
 409           return (double)DataValueInt();
 410   }
 411   else if (aType == SALOME_EvalVariant_UInt ) {
 412           return (double)DataValueUInt();
 413   }
 414   else if (aType == SALOME_EvalVariant_Double ) {
 415           return (double)DataValueDouble();
 416   }
 417   else if (aType == SALOME_EvalVariant_String) {
 418     double dRet;
 419     //
 420     const RString& aStr=DataValueString();
 421     const char *pStr=aStr.c_str();
 422     dRet=atof(pStr);
 423     return dRet;
 424   }
 425   return 0.;
 426 }
 427
 428 //=======================================================================
 429 //function : toString
 430 //purpose  :
 431 //=======================================================================
 432 RString SALOME_EvalVariant::toString() const
 433 {
 434   char buffer[32];
 435   RString aS;
 436   //
 437   SALOME_EvalVariantType aType=type();
 438   //
 439   if (aType == SALOME_EvalVariant_Boolean) {
 440     int iX;
 441     //
 442     iX=toInt();
 443     aS= iX? "true" : "false";
 444   }
 445   else if (aType == SALOME_EvalVariant_Int) {
 446     sprintf(buffer, "%d", DataValueInt());
 447     aS=buffer;
 448   }
 449   else if (aType == SALOME_EvalVariant_UInt ) {
 450     sprintf(buffer, "%d", (int)DataValueUInt());
 451     aS=buffer;
 452   }
 453   else if (aType == SALOME_EvalVariant_Double ) {
 454
 455     double aX;
 456     //
 457     aX=DataValueDouble();
 458     gcvt(aX, 12, buffer);
 459     aS=buffer;
 460   }
 461   else if (aType == SALOME_EvalVariant_String) {
 462     const RString& aStr=DataValueString();
 463     aS=aStr;
 464   }
 465   return aS;
 466 }
 467 //=======================================================================
 468 //function : toList
 469 //purpose  :
 470 //=======================================================================
 471 SALOME_ListOfEvalVariant SALOME_EvalVariant::toList() const
 472 {
 473   SALOME_ListOfEvalVariant aS;
 474   //
 475   SALOME_EvalVariantType aType=type();
 476   //
 477   if (aType == SALOME_EvalVariant_List) {
 478     aS=DataValueList();
 479   }
 480   return aS;
 481 }
 482 //=======================================================================
 483 //function : contains
 484 //purpose  :
 485 //=======================================================================
 486 bool SALOME_EvalVariant::contains(const SALOME_ListOfEvalVariant& aL,
 487                         const SALOME_EvalVariant& aV)
 488 {
 489   bool bRet;
 490   //
 491   bRet=false;
 492   SALOME_ListOfEvalVariant::const_iterator aIt = aL.begin();
 493   for ( ; aIt != aL.end(); ++aIt) {
 494     const SALOME_EvalVariant& aVx=*aIt;
 495     bRet=aVx==aV;
 496     if (bRet) {
 497       break;
 498     }
 499   }
 500   return bRet;
 501 }