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) 1991-2009 OpenCFD Ltd.
   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 the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     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, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*---------------------------------------------------------------------------*/
  26
  27 #include <iostream>
  28
  29 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  30
  31 namespace Foam
  32 {
  33
  34 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  35
  36 // Clear any allocated storage (word or string)
  37 inline void token::clear()
  38 {
  39     if (type_ == WORD)
  40     {
  41         delete wordTokenPtr_;
  42     }
  43     else if (type_ == STRING)
  44     {
  45         delete stringTokenPtr_;
  46     }
  47     else if (type_ == COMPOUND)
  48     {
  49         if (compoundTokenPtr_->okToDelete())
  50         {
  51             delete compoundTokenPtr_;
  52         }
  53         else
  54         {
  55             compoundTokenPtr_->refCount::operator--();
  56         }
  57     }
  58
  59     type_ = UNDEFINED;
  60 }
  61
  62
  63 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  64
  65 // Construct null
  66 inline token::token()
  67 :
  68     type_(UNDEFINED),
  69     lineNumber_(0)
  70 {}
  71
  72 // Construct as copy
  73 inline token::token(const token& t)
  74 :
  75     type_(t.type_),
  76     lineNumber_(t.lineNumber_)
  77 {
  78     switch (type_)
  79     {
  80         case token::UNDEFINED:
  81         break;
  82
  83         case PUNCTUATION:
  84             punctuationToken_ = t.punctuationToken_;
  85         break;
  86
  87         case WORD:
  88             wordTokenPtr_ = new word(*t.wordTokenPtr_);
  89         break;
  90
  91         case STRING:
  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 bool token::good() const
 183 {
 184     return (type_ != ERROR && type_ != UNDEFINED);
 185 }
 186
 187 inline bool token::undefined() const
 188 {
 189     return (type_ == UNDEFINED);
 190 }
 191
 192 inline bool token::error() const
 193 {
 194     return (type_ == ERROR);
 195 }
 196
 197 inline bool token::isPunctuation() const
 198 {
 199     return (type_ == PUNCTUATION);
 200 }
 201
 202 inline token::punctuationToken token::pToken() const
 203 {
 204     if (type_ == PUNCTUATION)
 205     {
 206         return punctuationToken_;
 207     }
 208     else
 209     {
 210         parseError("punctuation character");
 211         return NULL_TOKEN;
 212     }
 213 }
 214
 215 inline bool token::isWord() const
 216 {
 217     return (type_ == WORD);
 218 }
 219
 220 inline const word& token::wordToken() const
 221 {
 222     if (type_ == WORD)
 223     {
 224         return *wordTokenPtr_;
 225     }
 226     else
 227     {
 228         parseError("word");
 229         return word::null;
 230     }
 231 }
 232
 233 inline bool token::isString() const
 234 {
 235     return (type_ == STRING);
 236 }
 237
 238 inline const string& token::stringToken() const
 239 {
 240     if (type_ == STRING)
 241     {
 242         return *stringTokenPtr_;
 243     }
 244     else
 245     {
 246         parseError("string");
 247         return string::null;
 248     }
 249 }
 250
 251 inline bool token::isLabel() const
 252 {
 253     return (type_ == LABEL);
 254 }
 255
 256 inline label token::labelToken() const
 257 {
 258     if (type_ == LABEL)
 259     {
 260         return labelToken_;
 261     }
 262     else
 263     {
 264         parseError("label");
 265         return 0;
 266     }
 267 }
 268
 269 inline bool token::isFloatScalar() const
 270 {
 271     return (type_ == FLOAT_SCALAR);
 272 }
 273
 274 inline floatScalar token::floatScalarToken() const
 275 {
 276     if (type_ == FLOAT_SCALAR)
 277     {
 278         return floatScalarToken_;
 279     }
 280     else
 281     {
 282         parseError("floatScalar");
 283         return 0.0;
 284     }
 285 }
 286
 287
 288 inline bool token::isDoubleScalar() const
 289 {
 290     return (type_ == DOUBLE_SCALAR);
 291 }
 292
 293 inline doubleScalar token::doubleScalarToken() const
 294 {
 295     if (type_ == DOUBLE_SCALAR)
 296     {
 297         return doubleScalarToken_;
 298     }
 299     else
 300     {
 301         parseError("doubleScalar");
 302         return 0.0;
 303     }
 304 }
 305
 306
 307 inline bool token::isScalar() const
 308 {
 309     return (type_ == FLOAT_SCALAR || type_ == DOUBLE_SCALAR);
 310 }
 311
 312 inline scalar token::scalarToken() const
 313 {
 314     if (type_ == FLOAT_SCALAR)
 315     {
 316         return floatScalarToken_;
 317     }
 318     else if (type_ == DOUBLE_SCALAR)
 319     {
 320         return doubleScalarToken_;
 321     }
 322     else
 323     {
 324         parseError("scalar");
 325         return 0.0;
 326     }
 327 }
 328
 329 inline bool token::isNumber() const
 330 {
 331     return (type_ == LABEL || isScalar());
 332 }
 333
 334 inline scalar token::number() const
 335 {
 336     if (type_ == LABEL)
 337     {
 338         return labelToken_;
 339     }
 340     else if (isScalar())
 341     {
 342         return scalarToken();
 343     }
 344     else
 345     {
 346         parseError("number (label or scalar)");
 347         return 0.0;
 348     }
 349 }
 350
 351 inline bool token::isCompound() const
 352 {
 353     return (type_ == COMPOUND);
 354 }
 355
 356 inline const token::compound& token::compoundToken() const
 357 {
 358     if (type_ == COMPOUND)
 359     {
 360         return *compoundTokenPtr_;
 361     }
 362     else
 363     {
 364         parseError("compound");
 365         return *compoundTokenPtr_;
 366     }
 367 }
 368
 369
 370 inline label token::lineNumber() const
 371 {
 372     return lineNumber_;
 373 }
 374
 375 inline label& token::lineNumber()
 376 {
 377     return lineNumber_;
 378 }
 379
 380
 381 inline void token::setBad()
 382 {
 383     clear();
 384     type_ = ERROR;
 385 }
 386
 387
 388 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 389
 390 inline void token::operator=(const token& t)
 391 {
 392     clear();
 393     type_ = t.type_;
 394
 395     switch (type_)
 396     {
 397         case token::UNDEFINED:
 398         break;
 399
 400         case PUNCTUATION:
 401             punctuationToken_ = t.punctuationToken_;
 402         break;
 403
 404         case WORD:
 405             wordTokenPtr_ = new word(*t.wordTokenPtr_);
 406         break;
 407
 408         case STRING:
 409             stringTokenPtr_ = new string(*t.stringTokenPtr_);
 410         break;
 411
 412         case LABEL:
 413             labelToken_ = t.labelToken_;
 414         break;
 415
 416         case FLOAT_SCALAR:
 417             floatScalarToken_ = t.floatScalarToken_;
 418         break;
 419
 420         case DOUBLE_SCALAR:
 421             doubleScalarToken_ = t.doubleScalarToken_;
 422         break;
 423
 424         case COMPOUND:
 425             compoundTokenPtr_ = t.compoundTokenPtr_;
 426             compoundTokenPtr_->refCount::operator++();
 427         break;
 428
 429         case token::ERROR:
 430         break;
 431     }
 432
 433     lineNumber_ = t.lineNumber_;
 434 }
 435
 436 inline void token::operator=(const punctuationToken p)
 437 {
 438     clear();
 439     type_ = PUNCTUATION;
 440     punctuationToken_ = p;
 441 }
 442
 443 inline void token::operator=(word* wPtr)
 444 {
 445     clear();
 446     type_ = WORD;
 447     wordTokenPtr_ = wPtr;
 448 }
 449
 450 inline void token::operator=(const word& w)
 451 {
 452     operator=(new word(w));
 453 }
 454
 455 inline void token::operator=(string* sPtr)
 456 {
 457     clear();
 458     type_ = STRING;
 459     stringTokenPtr_ = sPtr;
 460 }
 461
 462 inline void token::operator=(const string& s)
 463 {
 464     operator=(new string(s));
 465 }
 466
 467 inline void token::operator=(const label l)
 468 {
 469     clear();
 470     type_ = LABEL;
 471     labelToken_ = l;
 472 }
 473
 474 inline void token::operator=(const floatScalar s)
 475 {
 476     clear();
 477     type_ = FLOAT_SCALAR;
 478     floatScalarToken_ = s;
 479 }
 480
 481 inline void token::operator=(const doubleScalar s)
 482 {
 483     clear();
 484     type_ = DOUBLE_SCALAR;
 485     doubleScalarToken_ = s;
 486 }
 487
 488 inline void token::operator=(token::compound* cPtr)
 489 {
 490     clear();
 491     type_ = COMPOUND;
 492     compoundTokenPtr_ = cPtr;
 493 }
 494
 495
 496 inline bool token::operator==(const token& t) const
 497 {
 498     if (type_ != t.type_)
 499     {
 500         return false;
 501     }
 502
 503     switch (type_)
 504     {
 505         case token::UNDEFINED:
 506             return true;
 507
 508         case PUNCTUATION:
 509             return punctuationToken_ == t.punctuationToken_;
 510
 511         case WORD:
 512             return *wordTokenPtr_ == *t.wordTokenPtr_;
 513
 514         case STRING:
 515             return *stringTokenPtr_ == *t.stringTokenPtr_;
 516
 517         case LABEL:
 518             return labelToken_ == t.labelToken_;
 519
 520         case FLOAT_SCALAR:
 521             return equal(floatScalarToken_, t.floatScalarToken_);
 522
 523         case DOUBLE_SCALAR:
 524             return equal(doubleScalarToken_, t.doubleScalarToken_);
 525
 526         case COMPOUND:
 527             return compoundTokenPtr_ == t.compoundTokenPtr_;
 528
 529         case token::ERROR:
 530             return true;
 531     }
 532
 533     return false;
 534 }
 535
 536 inline bool token::operator==(const punctuationToken p) const
 537 {
 538     return (type_ == PUNCTUATION && punctuationToken_ == p);
 539 }
 540
 541 inline bool token::operator==(const word& w) const
 542 {
 543     return (type_ == WORD && wordToken() == w);
 544 }
 545
 546 inline bool token::operator==(const string& s) const
 547 {
 548     return (type_ == STRING && stringToken() == s);
 549 }
 550
 551 inline bool token::operator==(const label l) const
 552 {
 553     return (type_ == LABEL && labelToken_ == l);
 554 }
 555
 556 inline bool token::operator==(const floatScalar s) const
 557 {
 558     return (type_ == FLOAT_SCALAR && equal(floatScalarToken_, s));
 559 }
 560
 561 inline bool token::operator==(const doubleScalar s) const
 562 {
 563     return (type_ == DOUBLE_SCALAR && equal(doubleScalarToken_, s));
 564 }
 565
 566 inline bool token::operator!=(const token& t) const
 567 {
 568     return !operator==(t);
 569 }
 570
 571 inline bool token::operator!=(const punctuationToken p) const
 572 {
 573     return !operator==(p);
 574 }
 575
 576 inline bool token::operator!=(const word& w) const
 577 {
 578     return !operator==(w);
 579 }
 580
 581 inline bool token::operator!=(const string& s) const
 582 {
 583     return !operator==(s);
 584 }
 585
 586 inline bool token::operator!=(const floatScalar s) const
 587 {
 588     return !operator==(s);
 589 }
 590
 591 inline bool token::operator!=(const doubleScalar s) const
 592 {
 593     return !operator==(s);
 594 }
 595
 596 inline bool token::operator!=(const label l) const
 597 {
 598     return !operator==(l);
 599 }
 600
 601
 602 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 603
 604 } // End namespace Foam
 605
 606 // ************************************************************************* //