src/OpenFOAM/db/IOstreams/token/token.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 Class
  25     Foam::token
  26
  27 Description
  28     A token holds items read from Istream.
  29
  30 SourceFiles
  31     tokenI.H
  32     token.C
  33     tokenIO.C
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifndef token_H
  38 #define token_H
  39
  40 #include "label.H"
  41 #include "uLabel.H"
  42 #include "scalar.H"
  43 #include "word.H"
  44 #include "InfoProxy.H"
  45 #include "refCount.H"
  46 #include "typeInfo.H"
  47
  48 #define NoHashTableC
  49 #include "runTimeSelectionTables.H"
  50
  51 #include <iostream>
  52
  53 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  54
  55 namespace Foam
  56 {
  57
  58 // Forward declaration of friend functions and operators
  59
  60 class token;
  61 Istream& operator>>(Istream&, token&);
  62 Ostream& operator<<(Ostream&, const token&);
  63
  64 /*---------------------------------------------------------------------------*\
  65                            Class token Declaration
  66 \*---------------------------------------------------------------------------*/
  67
  68 class token
  69 {
  70
  71 public:
  72
  73     //- Enumeration defining the types of token
  74     enum tokenType
  75     {
  76         UNDEFINED,
  77
  78         PUNCTUATION,
  79         WORD,
  80         STRING,
  81         VERBATIMSTRING,
  82         LABEL,
  83         FLOAT_SCALAR,
  84         DOUBLE_SCALAR,
  85         COMPOUND,
  86
  87         ERROR
  88     };
  89
  90
  91     //- Standard punctuation tokens
  92     enum punctuationToken
  93     {
  94         NULL_TOKEN     = '\0',
  95         SPACE          = ' ',
  96         TAB            = '\t',
  97         NL             = '\n',
  98
  99         END_STATEMENT  = ';',
 100         BEGIN_LIST     = '(',
 101         END_LIST       = ')',
 102         BEGIN_SQR      = '[',
 103         END_SQR        = ']',
 104         BEGIN_BLOCK    = '{',
 105         END_BLOCK      = '}',
 106         COLON          = ':',
 107         COMMA          = ',',
 108         HASH           = '#',
 109
 110         BEGIN_STRING   = '"',
 111         END_STRING     = BEGIN_STRING,
 112
 113         ASSIGN         = '=',
 114         ADD            = '+',
 115         SUBTRACT       = '-',
 116         MULTIPLY       = '*',
 117         DIVIDE         = '/'
 118     };
 119
 120
 121     //- Abstract base class for complex tokens
 122     class compound
 123     :
 124         public refCount
 125     {
 126         // Private data
 127
 128             bool empty_;
 129
 130
 131         // Private Member Functions
 132
 133             //- Disallow default bitwise copy construct
 134             compound(const compound&);
 135
 136             //- Disallow default bitwise assignment
 137             void operator=(const compound&);
 138
 139
 140     public:
 141
 142         //- Runtime type information
 143         TypeName("compound");
 144
 145
 146         //- Declare run-time constructor selection table
 147         declareRunTimeSelectionTable
 148         (
 149             autoPtr,
 150             compound,
 151             Istream,
 152             (Istream& is),
 153             (is)
 154         );
 155
 156
 157         // Constructors
 158
 159             //- Construct null
 160             compound()
 161             :
 162                 empty_(false)
 163             {}
 164
 165
 166         // Selectors
 167
 168             //- Select null constructed
 169             static autoPtr<compound> New(const word& type, Istream&);
 170
 171
 172         //- Destructor
 173         virtual ~compound();
 174
 175
 176         // Member Functions
 177
 178             // Access
 179
 180                 //- Return true if name is a compound type
 181                 static bool isCompound(const word& name);
 182
 183                 bool empty() const
 184                 {
 185                     return empty_;
 186                 }
 187
 188                 bool& empty()
 189                 {
 190                     return empty_;
 191                 }
 192
 193                 virtual label size() const = 0;
 194
 195
 196             // Check
 197
 198             // Edit
 199
 200             // Write
 201
 202                 virtual void write(Ostream&) const = 0;
 203
 204
 205         // IOstream Operators
 206
 207             friend Ostream& operator<<(Ostream&, const compound&);
 208     };
 209
 210
 211     //- A templated class for holding compound tokens
 212     template<class T>
 213     class Compound
 214     :
 215         public token::compound,
 216         public T
 217     {
 218     public:
 219
 220         //- Runtime type information
 221         TypeName("Compound<T>");
 222
 223         Compound(Istream& is)
 224         :
 225             T(is)
 226         {}
 227
 228         label size() const
 229         {
 230             return T::size();
 231         }
 232
 233         void write(Ostream& os) const
 234         {
 235             operator<<(os, static_cast<const T&>(*this));
 236         }
 237     };
 238
 239
 240     //- Static undefined token
 241     static token undefinedToken;
 242
 243
 244 private:
 245
 246     // Private data
 247
 248         //- The token type
 249         tokenType type_;
 250
 251         //- Anonymous Union of token types
 252         union
 253         {
 254             punctuationToken punctuationToken_;
 255             word* wordTokenPtr_;
 256             string* stringTokenPtr_;
 257             label labelToken_;
 258             floatScalar floatScalarToken_;
 259             doubleScalar doubleScalarToken_;
 260             mutable compound* compoundTokenPtr_;
 261         };
 262
 263         //- Line number in the file this token was read from
 264         label lineNumber_;
 265
 266
 267     // Private Member Functions
 268
 269         //- Clear any allocated storage (word or string)
 270         inline void clear();
 271
 272         // Parse error, expected 'expected', found ...
 273         void parseError(const char* expected) const;
 274
 275
 276 public:
 277
 278     // Static data members
 279
 280         static const char* const typeName;
 281
 282
 283     // Constructors
 284
 285         //- Construct null
 286         inline token();
 287
 288         //- Construct as copy
 289         inline token(const token&);
 290
 291         //- Construct punctuation character token
 292         inline token(punctuationToken, label lineNumber=0);
 293
 294         //- Construct word token
 295         inline token(const word&, label lineNumber=0);
 296
 297         //- Construct string token
 298         inline token(const string&, label lineNumber=0);
 299
 300         //- Construct label token
 301         inline token(const label, label lineNumber=0);
 302
 303         //- Construct floatScalar token
 304         inline token(const floatScalar, label lineNumber=0);
 305
 306         //- Construct doubleScalar token
 307         inline token(const doubleScalar, label lineNumber=0);
 308
 309         //- Construct from Istream
 310         token(Istream&);
 311
 312
 313     //- Destructor
 314     inline ~token();
 315
 316
 317     // Member functions
 318
 319         // Access
 320
 321             inline tokenType type() const;
 322             inline tokenType& type();
 323
 324             inline bool good() const;
 325             inline bool undefined() const;
 326             inline bool error() const;
 327
 328             inline bool isPunctuation() const;
 329             inline punctuationToken pToken() const;
 330
 331             inline bool isWord() const;
 332             inline const word& wordToken() const;
 333
 334             inline bool isString() const;
 335             inline const string& stringToken() const;
 336
 337             inline bool isLabel() const;
 338             inline label labelToken() const;
 339
 340             inline bool isFloatScalar() const;
 341             inline floatScalar floatScalarToken() const;
 342
 343             inline bool isDoubleScalar() const;
 344             inline doubleScalar doubleScalarToken() const;
 345
 346             inline bool isScalar() const;
 347             inline scalar scalarToken() const;
 348
 349             inline bool isNumber() const;
 350             inline scalar number() const;
 351
 352             inline bool isCompound() const;
 353             inline const compound& compoundToken() const;
 354             compound& transferCompoundToken();
 355
 356             inline label lineNumber() const;
 357             inline label& lineNumber();
 358
 359
 360         // Edit
 361
 362             //- Set bad
 363             inline void setBad();
 364
 365
 366         // Info
 367
 368             //- Return info proxy.
 369             //  Used to print token information to a stream
 370             InfoProxy<token> info() const
 371             {
 372                 return *this;
 373             }
 374
 375
 376     // Member operators
 377
 378         // Assignment
 379
 380             inline void operator=(const token&);
 381
 382             inline void operator=(const punctuationToken);
 383
 384             inline void operator=(word*);
 385             inline void operator=(const word&);
 386
 387             inline void operator=(string*);
 388             inline void operator=(const string&);
 389
 390             inline void operator=(const label);
 391             inline void operator=(const floatScalar);
 392             inline void operator=(const doubleScalar);
 393
 394             inline void operator=(compound*);
 395
 396
 397         // Equality
 398
 399             inline bool operator==(const token&) const;
 400             inline bool operator==(const punctuationToken) const;
 401             inline bool operator==(const word&) const;
 402             inline bool operator==(const string&) const;
 403             inline bool operator==(const label) const;
 404             inline bool operator==(const floatScalar) const;
 405             inline bool operator==(const doubleScalar) const;
 406
 407
 408         // Inequality
 409
 410             inline bool operator!=(const token&) const;
 411             inline bool operator!=(const punctuationToken) const;
 412             inline bool operator!=(const word&) const;
 413             inline bool operator!=(const string&) const;
 414             inline bool operator!=(const label) const;
 415             inline bool operator!=(const floatScalar) const;
 416             inline bool operator!=(const doubleScalar) const;
 417
 418
 419     // IOstream operators
 420
 421         friend Istream& operator>>(Istream&, token&);
 422         friend Ostream& operator<<(Ostream&, const token&);
 423
 424         friend Ostream& operator<<(Ostream&, const punctuationToken&);
 425         friend ostream& operator<<(ostream&, const punctuationToken&);
 426
 427         friend ostream& operator<<(ostream&, const InfoProxy<token>&);
 428 };
 429
 430
 431 Ostream& operator<<(Ostream&, const token::punctuationToken&);
 432 ostream& operator<<(ostream&, const token::punctuationToken&);
 433 ostream& operator<<(ostream&, const InfoProxy<token>&);
 434 Ostream& operator<<(Ostream&, const token::compound&);
 435
 436
 437 #define defineCompoundTypeName(Type, Name)                                    \
 438     defineTemplateTypeNameAndDebugWithName(token::Compound<Type>, #Type, 0);
 439
 440 #define addCompoundToRunTimeSelectionTable(Type, Name)                        \
 441     token::compound::addIstreamConstructorToTable<token::Compound<Type> >     \
 442         add##Name##IstreamConstructorToTable_;
 443
 444
 445 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 446
 447 } // End namespace Foam
 448
 449 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 450
 451 #include "tokenI.H"
 452 #include "Istream.H"
 453
 454 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 455
 456 #endif
 457
 458 // ************************************************************************* //