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

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