src/foam/db/IOstreams/token/tokenI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation, either version 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include <iostream>
  27
  28 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  29
  30 namespace Foam
  31 {
  32
  33 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  34
  35 // Clear any allocated storage (word or string)
  36 inline void token::clear()
  37 {
  38     if (type_ == WORD)
  39     {
  40         delete wordTokenPtr_;
  41     }
  42     else if (type_ == STRING)
  43     {
  44         delete stringTokenPtr_;
  45     }
  46     else if (type_ == COMPOUND)
  47     {
  48         if (compoundTokenPtr_->okToDelete())
  49         {
  50             delete compoundTokenPtr_;
  51         }
  52         else
  53         {
  54             compoundTokenPtr_->refCount::operator--();
  55         }
  56     }
  57
  58     type_ = UNDEFINED;
  59 }
  60
  61
  62 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  63
  64 // Construct null
  65 inline token::token()
  66 :
  67     type_(UNDEFINED),
  68     lineNumber_(0)
  69 {}
  70
  71 // Construct as copy
  72 inline token::token(const token& t)
  73 :
  74     type_(t.type_),
  75     lineNumber_(t.lineNumber_)
  76 {
  77     switch (type_)
  78     {
  79         case token::UNDEFINED:
  80         break;
  81
  82         case PUNCTUATION:
  83             punctuationToken_ = t.punctuationToken_;
  84         break;
  85
  86         case WORD:
  87             wordTokenPtr_ = new word(*t.wordTokenPtr_);
  88         break;
  89
  90         case STRING:
  91             stringTokenPtr_ = new string(*t.stringTokenPtr_);
  92         break;
  93
  94         case LABEL:
  95             labelToken_ = t.labelToken_;
  96         break;
  97
  98         case FLOAT_SCALAR:
  99             floatScalarToken_ = t.floatScalarToken_;
 100         break;
 101
 102         case DOUBLE_SCALAR:
 103             doubleScalarToken_ = t.doubleScalarToken_;
 104         break;
 105
 106         case LONG_DOUBLE_SCALAR:
 107             longDoubleScalarToken_ = t.longDoubleScalarToken_;
 108         break;
 109
 110         case COMPOUND:
 111             compoundTokenPtr_ = t.compoundTokenPtr_;
 112             compoundTokenPtr_->refCount::operator++();
 113         break;
 114
 115         case token::FATALERROR:
 116         break;
 117     }
 118 }
 119
 120 // Construct punctuation character token
 121 inline token::token(punctuationToken p, label lineNumber)
 122 :
 123     type_(PUNCTUATION),
 124     punctuationToken_(p),
 125     lineNumber_(lineNumber)
 126 {}
 127
 128 // Construct word token
 129 inline token::token(const word& w, label lineNumber)
 130 :
 131     type_(WORD),
 132     wordTokenPtr_(new word(w)),
 133     lineNumber_(lineNumber)
 134 {}
 135
 136 // Construct string token
 137 inline token::token(const string& s, label lineNumber)
 138 :
 139     type_(STRING),
 140     stringTokenPtr_(new string(s)),
 141     lineNumber_(lineNumber)
 142 {}
 143
 144 // Construct label token
 145 inline token::token(const label l, label lineNumber)
 146 :
 147     type_(LABEL),
 148     labelToken_(l),
 149     lineNumber_(lineNumber)
 150 {}
 151
 152 // Construct floatScalar token
 153 inline token::token(const floatScalar s, label lineNumber)
 154 :
 155     type_(FLOAT_SCALAR),
 156     floatScalarToken_(s),
 157     lineNumber_(lineNumber)
 158 {}
 159
 160 // Construct doubleScalar token
 161 inline token::token(const doubleScalar s, label lineNumber)
 162 :
 163     type_(DOUBLE_SCALAR),
 164     doubleScalarToken_(s),
 165     lineNumber_(lineNumber)
 166 {}
 167
 168
 169 // Construct longDoubleScalar token
 170 inline token::token(const longDoubleScalar s, label lineNumber)
 171 :
 172     type_(LONG_DOUBLE_SCALAR),
 173     longDoubleScalarToken_(s),
 174     lineNumber_(lineNumber)
 175 {}
 176
 177
 178 // * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
 179
 180 // Delete token clearing the storage used by word or string
 181 inline token::~token()
 182 {
 183     clear();
 184 }
 185
 186
 187 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 188
 189 inline token::tokenType token::type() const
 190 {
 191     return type_;
 192 }
 193
 194 inline bool token::good() const
 195 {
 196     return (type_ != FATALERROR && type_ != UNDEFINED);
 197 }
 198
 199 inline bool token::undefined() const
 200 {
 201     return (type_ == UNDEFINED);
 202 }
 203
 204 inline bool token::error() const
 205 {
 206     return (type_ == FATALERROR);
 207 }
 208
 209 inline bool token::isPunctuation() const
 210 {
 211     return (type_ == PUNCTUATION);
 212 }
 213
 214 inline token::punctuationToken token::pToken() const
 215 {
 216     if (type_ == PUNCTUATION)
 217     {
 218         return punctuationToken_;
 219     }
 220     else
 221     {
 222         parseError("punctuation character");
 223         return NULL_TOKEN;
 224     }
 225 }
 226
 227 inline bool token::isWord() const
 228 {
 229     return (type_ == WORD);
 230 }
 231
 232 inline const word& token::wordToken() const
 233 {
 234     if (type_ == WORD)
 235     {
 236         return *wordTokenPtr_;
 237     }
 238     else
 239     {
 240         parseError("word");
 241         return word::null;
 242     }
 243 }
 244
 245 inline bool token::isString() const
 246 {
 247     return (type_ == STRING);
 248 }
 249
 250 inline const string& token::stringToken() const
 251 {
 252     if (type_ == STRING)
 253     {
 254         return *stringTokenPtr_;
 255     }
 256     else
 257     {
 258         parseError("string");
 259         return string::null;
 260     }
 261 }
 262
 263 inline bool token::isLabel() const
 264 {
 265     return (type_ == LABEL);
 266 }
 267
 268 inline label token::labelToken() const
 269 {
 270     if (type_ == LABEL)
 271     {
 272         return labelToken_;
 273     }
 274     else
 275     {
 276         parseError("label");
 277         return 0;
 278     }
 279 }
 280
 281 inline bool token::isFloatScalar() const
 282 {
 283     return (type_ == FLOAT_SCALAR);
 284 }
 285
 286 inline floatScalar token::floatScalarToken() const
 287 {
 288     if (type_ == FLOAT_SCALAR)
 289     {
 290         return floatScalarToken_;
 291     }
 292     else
 293     {
 294         parseError("floatScalar");
 295         return 0.0;
 296     }
 297 }
 298
 299
 300 inline bool token::isDoubleScalar() const
 301 {
 302     return (type_ == DOUBLE_SCALAR);
 303 }
 304
 305
 306 inline doubleScalar token::doubleScalarToken() const
 307 {
 308     if (type_ == DOUBLE_SCALAR)
 309     {
 310         return doubleScalarToken_;
 311     }
 312     else
 313     {
 314         parseError("doubleScalar");
 315         return 0.0;
 316     }
 317 }
 318
 319
 320 inline bool token::isLongDoubleScalar() const
 321 {
 322     return (type_ == LONG_DOUBLE_SCALAR);
 323 }
 324
 325
 326 inline longDoubleScalar token::longDoubleScalarToken() const
 327 {
 328     if (type_ == LONG_DOUBLE_SCALAR)
 329     {
 330         return longDoubleScalarToken_;
 331     }
 332     else
 333     {
 334         parseError("longDoubleScalar");
 335         return 0.0;
 336     }
 337 }
 338
 339
 340 inline bool token::isScalar() const
 341 {
 342     return
 343     (
 344         type_ == FLOAT_SCALAR
 345      || type_ == DOUBLE_SCALAR
 346      || type_ == LONG_DOUBLE_SCALAR
 347     );
 348 }
 349
 350 inline scalar token::scalarToken() const
 351 {
 352     if (type_ == FLOAT_SCALAR)
 353     {
 354         return floatScalarToken_;
 355     }
 356     else if (type_ == DOUBLE_SCALAR)
 357     {
 358         return doubleScalarToken_;
 359     }
 360     else if (type_ == LONG_DOUBLE_SCALAR)
 361     {
 362         return longDoubleScalarToken_;
 363     }
 364     else
 365     {
 366         parseError("scalar");
 367         return 0.0;
 368     }
 369 }
 370
 371 inline bool token::isNumber() const
 372 {
 373     return (type_ == LABEL || isScalar());
 374 }
 375
 376 inline scalar token::number() const
 377 {
 378     if (type_ == LABEL)
 379     {
 380         return labelToken_;
 381     }
 382     else if (isScalar())
 383     {
 384         return scalarToken();
 385     }
 386     else
 387     {
 388         parseError("number (label or scalar)");
 389         return 0.0;
 390     }
 391 }
 392
 393 inline bool token::isCompound() const
 394 {
 395     return (type_ == COMPOUND);
 396 }
 397
 398 inline const token::compound& token::compoundToken() const
 399 {
 400     if (type_ == COMPOUND)
 401     {
 402         return *compoundTokenPtr_;
 403     }
 404     else
 405     {
 406         parseError("compound");
 407         return *compoundTokenPtr_;
 408     }
 409 }
 410
 411
 412 inline label token::lineNumber() const
 413 {
 414     return lineNumber_;
 415 }
 416
 417 inline label& token::lineNumber()
 418 {
 419     return lineNumber_;
 420 }
 421
 422
 423 inline void token::setBad()
 424 {
 425     clear();
 426     type_ = FATALERROR;
 427 }
 428
 429
 430 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 431
 432 inline void token::operator=(const token& t)
 433 {
 434     clear();
 435     type_ = t.type_;
 436
 437     switch (type_)
 438     {
 439         case token::UNDEFINED:
 440         break;
 441
 442         case PUNCTUATION:
 443             punctuationToken_ = t.punctuationToken_;
 444         break;
 445
 446         case WORD:
 447             wordTokenPtr_ = new word(*t.wordTokenPtr_);
 448         break;
 449
 450         case STRING:
 451             stringTokenPtr_ = new string(*t.stringTokenPtr_);
 452         break;
 453
 454         case LABEL:
 455             labelToken_ = t.labelToken_;
 456         break;
 457
 458         case FLOAT_SCALAR:
 459             floatScalarToken_ = t.floatScalarToken_;
 460         break;
 461
 462         case DOUBLE_SCALAR:
 463             doubleScalarToken_ = t.doubleScalarToken_;
 464         break;
 465
 466         case LONG_DOUBLE_SCALAR:
 467             longDoubleScalarToken_ = t.longDoubleScalarToken_;
 468         break;
 469
 470         case COMPOUND:
 471             compoundTokenPtr_ = t.compoundTokenPtr_;
 472             compoundTokenPtr_->refCount::operator++();
 473         break;
 474
 475         case token::FATALERROR:
 476         break;
 477     }
 478
 479     lineNumber_ = t.lineNumber_;
 480 }
 481
 482
 483 inline void token::operator=(const punctuationToken p)
 484 {
 485     clear();
 486     type_ = PUNCTUATION;
 487     punctuationToken_ = p;
 488 }
 489
 490 inline void token::operator=(word* wPtr)
 491 {
 492     clear();
 493     type_ = WORD;
 494     wordTokenPtr_ = wPtr;
 495 }
 496
 497 inline void token::operator=(const word& w)
 498 {
 499     operator=(new word(w));
 500 }
 501
 502 inline void token::operator=(string* sPtr)
 503 {
 504     clear();
 505     type_ = STRING;
 506     stringTokenPtr_ = sPtr;
 507 }
 508
 509 inline void token::operator=(const string& s)
 510 {
 511     operator=(new string(s));
 512 }
 513
 514 inline void token::operator=(const label l)
 515 {
 516     clear();
 517     type_ = LABEL;
 518     labelToken_ = l;
 519 }
 520
 521 inline void token::operator=(const floatScalar s)
 522 {
 523     clear();
 524     type_ = FLOAT_SCALAR;
 525     floatScalarToken_ = s;
 526 }
 527
 528 inline void token::operator=(const doubleScalar s)
 529 {
 530     clear();
 531     type_ = DOUBLE_SCALAR;
 532     doubleScalarToken_ = s;
 533 }
 534
 535 inline void token::operator=(const longDoubleScalar s)
 536 {
 537     clear();
 538     type_ = LONG_DOUBLE_SCALAR;
 539     longDoubleScalarToken_ = s;
 540 }
 541
 542 inline void token::operator=(token::compound* cPtr)
 543 {
 544     clear();
 545     type_ = COMPOUND;
 546     compoundTokenPtr_ = cPtr;
 547 }
 548
 549
 550 inline bool token::operator==(const token& t) const
 551 {
 552     if (type_ != t.type_)
 553     {
 554         return false;
 555     }
 556
 557     switch (type_)
 558     {
 559         case token::UNDEFINED:
 560             return true;
 561
 562         case PUNCTUATION:
 563             return punctuationToken_ == t.punctuationToken_;
 564
 565         case WORD:
 566             return *wordTokenPtr_ == *t.wordTokenPtr_;
 567
 568         case STRING:
 569             return *stringTokenPtr_ == *t.stringTokenPtr_;
 570
 571         case LABEL:
 572             return labelToken_ == t.labelToken_;
 573
 574         case FLOAT_SCALAR:
 575             return equal(floatScalarToken_, t.floatScalarToken_);
 576
 577         case DOUBLE_SCALAR:
 578             return equal(doubleScalarToken_, t.doubleScalarToken_);
 579
 580         case LONG_DOUBLE_SCALAR:
 581             return equal(longDoubleScalarToken_, t.longDoubleScalarToken_);
 582
 583         case COMPOUND:
 584             return compoundTokenPtr_ == t.compoundTokenPtr_;
 585
 586         case token::FATALERROR:
 587             return true;
 588     }
 589
 590     return false;
 591 }
 592
 593 inline bool token::operator==(const punctuationToken p) const
 594 {
 595     return (type_ == PUNCTUATION && punctuationToken_ == p);
 596 }
 597
 598 inline bool token::operator==(const word& w) const
 599 {
 600     return (type_ == WORD && wordToken() == w);
 601 }
 602
 603 inline bool token::operator==(const string& s) const
 604 {
 605     return (type_ == STRING && stringToken() == s);
 606 }
 607
 608 inline bool token::operator==(const label l) const
 609 {
 610     return (type_ == LABEL && labelToken_ == l);
 611 }
 612
 613 inline bool token::operator==(const floatScalar s) const
 614 {
 615     return (type_ == FLOAT_SCALAR && equal(floatScalarToken_, s));
 616 }
 617
 618 inline bool token::operator==(const doubleScalar s) const
 619 {
 620     return (type_ == DOUBLE_SCALAR && equal(doubleScalarToken_, s));
 621 }
 622
 623 inline bool token::operator==(const longDoubleScalar s) const
 624 {
 625     return (type_ == LONG_DOUBLE_SCALAR && equal(longDoubleScalarToken_, s));
 626 }
 627
 628 inline bool token::operator!=(const token& t) const
 629 {
 630     return !operator==(t);
 631 }
 632
 633 inline bool token::operator!=(const punctuationToken p) const
 634 {
 635     return !operator==(p);
 636 }
 637
 638 inline bool token::operator!=(const word& w) const
 639 {
 640     return !operator==(w);
 641 }
 642
 643 inline bool token::operator!=(const string& s) const
 644 {
 645     return !operator==(s);
 646 }
 647
 648 inline bool token::operator!=(const floatScalar s) const
 649 {
 650     return !operator==(s);
 651 }
 652
 653 inline bool token::operator!=(const doubleScalar s) const
 654 {
 655     return !operator==(s);
 656 }
 657
 658 inline bool token::operator!=(const longDoubleScalar s) const
 659 {
 660     return !operator==(s);
 661 }
 662
 663 inline bool token::operator!=(const label l) const
 664 {
 665     return !operator==(l);
 666 }
 667
 668
 669 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 670
 671 } // End namespace Foam
 672
 673 // ************************************************************************* //