src/Units/Units_Token.cxx

   1 // Created on: 1992-06-24
   2 // Created by: Gilles DEBARBOUILLE
   3 // Copyright (c) 1992-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and/or modify it under
   9 // the terms of the GNU Lesser General Public License version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17 // Updated:     Gerard GRAS le 090597
  18 //              reason is PRO6934 -> plantage sur HP 10.2
  19 //              changes are : Replace the field theword,themean from HAsciiString
  20 //                            to AsciiString.
  21 //              because the compiler try to destroies the handle of HAsciiString to early
  22 //              due to inline use probably.
  23 //              See also Units_Token.lxx
  24
  25 #define PRO8727 //GG_180697
  26 //              Mauvaise construction d'un token par copie
  27 //              plantatoire sur HP.
  28
  29 #include <Units_Token.ixx>
  30 #include <TCollection_AsciiString.hxx>
  31 #include <Units_Operators.hxx>
  32
  33 #define XTRACE 1
  34
  35 //=======================================================================
  36 //function : Units_Token
  37 //purpose  :
  38 //=======================================================================
  39
  40 Units_Token::Units_Token()
  41 {
  42   theword=" ";
  43   themean=" ";
  44   thevalue=0.;
  45   thedimensions=new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.);
  46 #ifdef TRACE
  47   cout << " CREATES Token " << endl;
  48   Dump(0,0);
  49 #endif
  50 }
  51
  52 //=======================================================================
  53 //function : Units_Token
  54 //purpose  :
  55 //=======================================================================
  56
  57 Units_Token::Units_Token(const Standard_CString aword)
  58 {
  59   theword=aword;
  60   themean=" ";
  61   thevalue=0.;
  62   thedimensions=new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.);
  63 #ifdef TRACE
  64   cout << " CREATES Token " << endl;
  65   Dump(0,0);
  66 #endif
  67 }
  68
  69 //=======================================================================
  70 //function : Units_Token
  71 //purpose  :
  72 //=======================================================================
  73
  74 Units_Token::Units_Token(const Standard_CString aword,
  75                          const Standard_CString amean)
  76 {
  77   theword=aword;
  78   themean=amean;
  79   thevalue=0.;
  80   thedimensions=new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.);
  81 #ifdef TRACE
  82   cout << " CREATES Token " << endl;
  83   Dump(0,0);
  84 #endif
  85 }
  86
  87 //=======================================================================
  88 //function : Units_Token
  89 //purpose  :
  90 //=======================================================================
  91
  92 Units_Token::Units_Token(const Standard_CString aword,
  93                          const Standard_CString amean,
  94                          const Standard_Real avalue)
  95 {
  96   theword=aword;
  97   themean=amean;
  98   thevalue=avalue;
  99   thedimensions=new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.);
 100 #ifdef TRACE
 101   cout << " CREATES Token " << endl;
 102   Dump(0,0);
 103 #endif
 104 }
 105
 106 //=======================================================================
 107 //function : Units_Token
 108 //purpose  :
 109 //=======================================================================
 110
 111 Units_Token::Units_Token(const Standard_CString aword,
 112                          const Standard_CString amean,
 113                          const Standard_Real avalue,
 114                          const Handle(Units_Dimensions)& adimensions)
 115 {
 116   theword=aword;
 117   themean=amean;
 118   thevalue=avalue;
 119   if(adimensions.IsNull())
 120     thedimensions = new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.);
 121   else
 122     thedimensions = new Units_Dimensions(adimensions->Mass(),
 123                                          adimensions->Length(),
 124                                          adimensions->Time(),
 125                                          adimensions->ElectricCurrent(),
 126                                          adimensions->ThermodynamicTemperature(),
 127                                          adimensions->AmountOfSubstance(),
 128                                          adimensions->LuminousIntensity(),
 129                                          adimensions->PlaneAngle(),
 130                                          adimensions->SolidAngle());
 131 #ifdef TRACE
 132   cout << " CREATES Token " << endl;
 133   Dump(0,0);
 134 #endif
 135 }
 136
 137 //=======================================================================
 138 //function : Creates
 139 //purpose  :
 140 //=======================================================================
 141
 142 Handle(Units_Token) Units_Token::Creates() const
 143 {
 144 #ifdef PRO8727
 145   TCollection_AsciiString word = Word();
 146   TCollection_AsciiString mean = Mean();
 147   return new Units_Token(word.ToCString(),mean.ToCString(),Value(),Dimensions());
 148 #else
 149   return new Units_Token(*this);
 150 #endif
 151 }
 152
 153 //=======================================================================
 154 //function : Length
 155 //purpose  :
 156 //=======================================================================
 157
 158 Standard_Integer Units_Token::Length() const
 159 {
 160   return theword.Length();
 161 }
 162
 163 //=======================================================================
 164 //function : Dimensions
 165 //purpose  :
 166 //=======================================================================
 167
 168 void Units_Token::Dimensions(const Handle(Units_Dimensions)& adimensions)
 169 {
 170   if(adimensions.IsNull())
 171     thedimensions = new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.);
 172   else
 173     thedimensions = new Units_Dimensions(adimensions->Mass(),
 174                                          adimensions->Length(),
 175                                          adimensions->Time(),
 176                                          adimensions->ElectricCurrent(),
 177                                          adimensions->ThermodynamicTemperature(),
 178                                          adimensions->AmountOfSubstance(),
 179                                          adimensions->LuminousIntensity(),
 180                                          adimensions->PlaneAngle(),
 181                                          adimensions->SolidAngle());
 182 }
 183
 184 //=======================================================================
 185 //function : Units_Token
 186 //purpose  :
 187 //=======================================================================
 188
 189 Units_Token::Units_Token(const Handle(Units_Token)& atoken)
 190 {
 191   theword       = atoken->Word();
 192   themean       = atoken->Mean();
 193   thevalue      = atoken->Value();
 194   thedimensions = atoken->Dimensions();
 195 }
 196
 197 //=======================================================================
 198 //function : Update
 199 //purpose  :
 200 //=======================================================================
 201
 202 void Units_Token::Update(const Standard_CString amean)
 203 {
 204   TCollection_AsciiString string = Mean();
 205   if(string.Search(amean) != -1)
 206     cout<<Word()<<" encountered twice with the same signification : "<<amean<<endl;
 207   string = string + amean;
 208   themean = string;
 209 }
 210
 211 //=======================================================================
 212 //function : Add
 213 //purpose  :
 214 //=======================================================================
 215
 216 Handle(Units_Token) Units_Token::Add (const Standard_Integer) const
 217 {
 218 //  Standard_CString s=new char[thelength+1];
 219 //  strcpy(s,theword);
 220 //  s[thelength-1]=s[thelength-1]+int(i);
 221   return new Units_Token();
 222 }
 223
 224 //=======================================================================
 225 //function : Add
 226 //purpose  :
 227 //=======================================================================
 228
 229 Handle(Units_Token) Units_Token::Add (const Handle(Units_Token)& atoken) const
 230 {
 231   TCollection_AsciiString word = Word();
 232   if(thedimensions->IsEqual(atoken->Dimensions()))
 233     return new Units_Token(word.ToCString(), " ", thevalue+atoken->Value(), thedimensions);
 234   else
 235     return new Units_Token(" ");
 236 }
 237
 238 //=======================================================================
 239 //function : Subtract
 240 //purpose  :
 241 //=======================================================================
 242
 243 Handle(Units_Token) Units_Token::Subtract (const Handle(Units_Token)& atoken) const
 244 {
 245   TCollection_AsciiString word = Word();
 246   if(thedimensions->IsEqual(atoken->Dimensions()))
 247     return new Units_Token(word.ToCString(), " ", thevalue-atoken->Value(), thedimensions);
 248   else
 249     return new Units_Token(" ");
 250 }
 251
 252 //=======================================================================
 253 //function : Multiply
 254 //purpose  :
 255 //=======================================================================
 256
 257 Handle(Units_Token) Units_Token::Multiply (const Handle(Units_Token)& atoken) const
 258 {
 259   TCollection_AsciiString string = Word();
 260   string.Insert(1,'(');
 261   string = string + ")*(";
 262   string = string + atoken->Word();
 263   string = string + ")";
 264   return new Units_Token
 265     (string.ToCString()," ", thevalue*atoken->Value(), thedimensions * (atoken->Dimensions()));
 266 }
 267
 268 //=======================================================================
 269 //function : Multiplied
 270 //purpose  :
 271 //=======================================================================
 272
 273 Standard_Real Units_Token::Multiplied (const Standard_Real avalue) const
 274 {
 275   return avalue * thevalue;
 276 }
 277
 278 //=======================================================================
 279 //function : Divide
 280 //purpose  :
 281 //=======================================================================
 282
 283 Handle(Units_Token) Units_Token::Divide (const Handle(Units_Token)& atoken)
 284      const
 285 {
 286   if(fabs(atoken->Value())<1.e-40) {
 287 #ifdef OCCT_DEBUG
 288     cout<<"Warning: division on token with value=0 => return initial token."<<endl;
 289 #endif
 290     return this;
 291   }
 292   TCollection_AsciiString string = Word();
 293   string.Insert(1,'(');
 294   string = string + ")/(";
 295   string = string + atoken->Word();
 296   string = string + ")";
 297   return new Units_Token
 298     (string.ToCString()," ", thevalue/atoken->Value(), thedimensions / (atoken->Dimensions()));
 299 }
 300
 301 //=======================================================================
 302 //function : Divided
 303 //purpose  :
 304 //=======================================================================
 305
 306 Standard_Real Units_Token::Divided (const Standard_Real avalue) const
 307 {
 308   return avalue / thevalue;
 309 }
 310
 311 //=======================================================================
 312 //function : Power
 313 //purpose  :
 314 //=======================================================================
 315
 316 Handle(Units_Token) Units_Token::Power(const Handle(Units_Token)& atoken) const
 317 {
 318   TCollection_AsciiString string = Word();
 319   string.Insert(1,'(');
 320   string = string + ")**(";
 321   string = string + atoken->Word();
 322   string = string + ")";
 323   return new Units_Token
 324     (string.ToCString()," ",pow(thevalue,atoken->Value()),pow(thedimensions,atoken->Value()));
 325 }
 326
 327 //=======================================================================
 328 //function : Power
 329 //purpose  :
 330 //=======================================================================
 331
 332 Handle(Units_Token) Units_Token::Power(const Standard_Real anexponent) const
 333 {
 334   TCollection_AsciiString exponent(anexponent);
 335   TCollection_AsciiString string = Word();
 336   string.Insert(1,'(');
 337   string = string + ")**(";
 338   string = string + exponent;
 339   string = string + ")";
 340   return new Units_Token
 341     (string.ToCString()," ",pow(thevalue,anexponent),pow(thedimensions,anexponent));
 342 }
 343
 344 //=======================================================================
 345 //function : IsEqual
 346 //purpose  :
 347 //=======================================================================
 348
 349 Standard_Boolean Units_Token::IsEqual (const Standard_CString astring) const
 350 {
 351   TCollection_AsciiString string = Word();
 352 #ifdef UNX
 353   Standard_Integer length = string.Length();
 354 #else
 355   unsigned int length = string.Length();
 356 #endif
 357   if(strlen(astring) == length)
 358     return (strncmp(string.ToCString(),astring,unsigned(length)) == 0)
 359       ? Standard_True : Standard_False;
 360   else
 361     return Standard_False;
 362 }
 363
 364 //=======================================================================
 365 //function : IsEqual
 366 //purpose  :
 367 //=======================================================================
 368
 369 Standard_Boolean Units_Token::IsEqual (const Handle(Units_Token)& atoken) const
 370 {
 371   TCollection_AsciiString string1 = Word();
 372   TCollection_AsciiString string2 = atoken->Word();
 373   Standard_Integer length = string1.Length();
 374   if(length == atoken->Length())
 375     return (strcmp(string1.ToCString(),string2.ToCString()) == 0) ? Standard_True : Standard_False;
 376   else
 377     return Standard_False;
 378 }
 379
 380 //=======================================================================
 381 //function : Dump
 382 //purpose  :
 383 //=======================================================================
 384
 385 void Units_Token::Dump(const Standard_Integer ashift,
 386                        const Standard_Integer alevel) const
 387 {
 388   int i;
 389   TCollection_AsciiString word = Word();
 390   TCollection_AsciiString mean = Mean();
 391
 392   for(i=0; i<ashift; i++)cout<<"  ";
 393   cout << "Units_Token::Dump of " << this << endl;
 394   for(i=0; i<ashift; i++)cout<<"  ";
 395   cout<<word.ToCString()<<endl;
 396   for(i=0; i<ashift; i++)cout<<"  ";
 397   cout<<"  value : "<<thevalue<<endl;
 398   for(i=0; i<ashift; i++)cout<<"  ";
 399   cout<<"  mean  : "<<mean.ToCString()<<endl;
 400   if(alevel)thedimensions->Dump(ashift);
 401 }
 402
 403 //=======================================================================
 404 //function : operator +
 405 //purpose  :
 406 //=======================================================================
 407
 408 Handle(Units_Token) operator +(const Handle(Units_Token)& atoken,const Standard_Integer aninteger)
 409 {
 410   return atoken->Add(aninteger);
 411 }
 412
 413 //=======================================================================
 414 //function : operator +
 415 //purpose  :
 416 //=======================================================================
 417
 418 Handle(Units_Token) operator +(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
 419 {
 420   return atoken1->Add(atoken2);
 421 }
 422
 423 //=======================================================================
 424 //function : operator -
 425 //purpose  :
 426 //=======================================================================
 427
 428 Handle(Units_Token) operator -(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
 429 {
 430   return atoken1->Subtract(atoken2);
 431 }
 432
 433 //=======================================================================
 434 //function : operator *
 435 //purpose  :
 436 //=======================================================================
 437
 438 Handle(Units_Token) operator *(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
 439 {
 440   return atoken1->Multiply(atoken2);
 441 }
 442
 443 //=======================================================================
 444 //function : operator /
 445 //purpose  :
 446 //=======================================================================
 447
 448 Handle(Units_Token) operator /(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
 449 {
 450   return atoken1->Divide(atoken2);
 451 }
 452
 453 //=======================================================================
 454 //function : pow
 455 //purpose  :
 456 //=======================================================================
 457
 458 Handle(Units_Token) pow(const Handle(Units_Token)& atoken1, const Handle(Units_Token)& atoken2)
 459 {
 460   return atoken1->Power(atoken2);
 461 }
 462
 463 //=======================================================================
 464 //function : pow
 465 //purpose  :
 466 //=======================================================================
 467
 468 Handle(Units_Token) pow(const Handle(Units_Token)& atoken,const Standard_Real areal)
 469 {
 470   return atoken->Power(areal);
 471 }
 472
 473 //=======================================================================
 474 //function : operator ==
 475 //purpose  :
 476 //=======================================================================
 477
 478 Standard_Boolean operator ==(const Handle(Units_Token)& atoken,const Standard_CString astring)
 479 {
 480   return atoken->IsEqual(astring);
 481 }
 482
 483 //=======================================================================
 484 //function : operator ==
 485 //purpose  :
 486 //=======================================================================
 487
 488 //Standard_Boolean operator ==(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
 489 //{
 490 //  return atoken1->IsEqual(atoken2);
 491 //}
 492
 493 //=======================================================================
 494 //function : operator !=
 495 //purpose  :
 496 //=======================================================================
 497
 498 Standard_Boolean operator !=(const Handle(Units_Token)& atoken,const Standard_CString astring)
 499 {
 500   return atoken->IsNotEqual(astring);
 501 }
 502
 503 //=======================================================================
 504 //function : operator !=
 505 //purpose  :
 506 //=======================================================================
 507
 508 //Standard_Boolean operator !=(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
 509 //{
 510 //  return atoken1->IsNotEqual(atoken2);
 511 //}
 512
 513 //=======================================================================
 514 //function : operator <=
 515 //purpose  :
 516 //=======================================================================
 517
 518 Standard_Boolean operator <=(const Handle(Units_Token)& atoken,const Standard_CString astring)
 519 {
 520   return atoken->IsLessOrEqual(astring);
 521 }
 522
 523 //=======================================================================
 524 //function : operator >
 525 //purpose  :
 526 //=======================================================================
 527
 528 Standard_Boolean operator >(const Handle(Units_Token)& atoken,const Standard_CString astring)
 529 {
 530   return atoken->IsGreater(astring);
 531 }
 532
 533 //=======================================================================
 534 //function : operator >
 535 //purpose  :
 536 //=======================================================================
 537
 538 Standard_Boolean operator >(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
 539 {
 540   return atoken1->IsGreater(atoken2);
 541 }
 542
 543 //=======================================================================
 544 //function : operator >=
 545 //purpose  :
 546 //=======================================================================
 547
 548 Standard_Boolean operator >=(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
 549 {
 550   return atoken1->IsGreaterOrEqual(atoken2);
 551 }
 552
 553 void Units_Token::Destroy () {
 554
 555 #ifdef TRACE
 556  cout << " DESTROIES Token" << endl;
 557  Dump(0,0);
 558 #endif
 559 }