src/OpenFOAM/db/dictionary/primitiveEntry/primitiveEntryIO.C

   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 Description
  25     PrimitiveEntry constructor from Istream and Ostream output operator.
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #include "primitiveEntry.H"
  30 #include "functionEntry.H"
  31
  32 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  33
  34 void Foam::primitiveEntry::append
  35 (
  36     const token& currToken,
  37     const dictionary& dict,
  38     Istream& is
  39 )
  40 {
  41     if (currToken.isWord())
  42     {
  43         const word& w = currToken.wordToken();
  44
  45         if
  46         (
  47             disableFunctionEntries
  48          || w.size() == 1
  49          || (
  50                 !(w[0] == '$' && expandVariable(w, dict))
  51              && !(w[0] == '#' && expandFunction(w, dict, is))
  52             )
  53         )
  54         {
  55             newElmt(tokenIndex()++) = currToken;
  56         }
  57     }
  58     else
  59     {
  60         newElmt(tokenIndex()++) = currToken;
  61     }
  62 }
  63
  64
  65 bool Foam::primitiveEntry::expandFunction
  66 (
  67     const word& keyword,
  68     const dictionary& parentDict,
  69     Istream& is
  70 )
  71 {
  72     word functionName = keyword(1, keyword.size()-1);
  73     return functionEntry::execute(functionName, parentDict, *this, is);
  74 }
  75
  76
  77 bool Foam::primitiveEntry::read(const dictionary& dict, Istream& is)
  78 {
  79     is.fatalCheck
  80     (
  81         "primitiveEntry::readData(const dictionary&, Istream&)"
  82     );
  83
  84     label blockCount = 0;
  85     token currToken;
  86
  87     if
  88     (
  89         !is.read(currToken).bad()
  90      && currToken.good()
  91      && currToken != token::END_STATEMENT
  92     )
  93     {
  94         append(currToken, dict, is);
  95
  96         if
  97         (
  98             currToken == token::BEGIN_BLOCK
  99          || currToken == token::BEGIN_LIST
 100         )
 101         {
 102             blockCount++;
 103         }
 104
 105         while
 106         (
 107             !is.read(currToken).bad()
 108          && currToken.good()
 109          && !(currToken == token::END_STATEMENT && blockCount == 0)
 110         )
 111         {
 112             if
 113             (
 114                 currToken == token::BEGIN_BLOCK
 115              || currToken == token::BEGIN_LIST
 116             )
 117             {
 118                 blockCount++;
 119             }
 120             else if
 121             (
 122                 currToken == token::END_BLOCK
 123              || currToken == token::END_LIST
 124             )
 125             {
 126                 blockCount--;
 127             }
 128
 129             append(currToken, dict, is);
 130         }
 131     }
 132
 133     is.fatalCheck
 134     (
 135         "primitiveEntry::readData(const dictionary&, Istream&)"
 136     );
 137
 138     if (currToken.good())
 139     {
 140         return true;
 141     }
 142     else
 143     {
 144         return false;
 145     }
 146 }
 147
 148
 149 void Foam::primitiveEntry::readEntry(const dictionary& dict, Istream& is)
 150 {
 151     label keywordLineNumber = is.lineNumber();
 152     tokenIndex() = 0;
 153
 154     if (read(dict, is))
 155     {
 156         setSize(tokenIndex());
 157         tokenIndex() = 0;
 158     }
 159     else
 160     {
 161         std::ostringstream os;
 162         os  << "ill defined primitiveEntry starting at keyword '"
 163             << keyword() << '\''
 164             << " on line " << keywordLineNumber
 165             << " and ending at line " << is.lineNumber();
 166
 167         SafeFatalIOErrorIn
 168         (
 169             "primitiveEntry::readEntry(const dictionary&, Istream&)",
 170             is,
 171             os.str()
 172         );
 173     }
 174 }
 175
 176
 177 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 178
 179 Foam::primitiveEntry::primitiveEntry
 180 (
 181     const keyType& key,
 182     const dictionary& dict,
 183     Istream& is
 184 )
 185 :
 186     entry(key),
 187     ITstream
 188     (
 189         is.name() + "::" + key,
 190         tokenList(10),
 191         is.format(),
 192         is.version()
 193     )
 194 {
 195     readEntry(dict, is);
 196 }
 197
 198
 199 Foam::primitiveEntry::primitiveEntry(const keyType& key, Istream& is)
 200 :
 201     entry(key),
 202     ITstream
 203     (
 204         is.name() + "::" + key,
 205         tokenList(10),
 206         is.format(),
 207         is.version()
 208     )
 209 {
 210     readEntry(dictionary::null, is);
 211 }
 212
 213
 214 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 215
 216 void Foam::primitiveEntry::write(Ostream& os, const bool contentsOnly) const
 217 {
 218     if (!contentsOnly)
 219     {
 220         os.writeKeyword(keyword());
 221     }
 222
 223     for (label i=0; i<size(); ++i)
 224     {
 225         const token& t = operator[](i);
 226         if (t.type() == token::VERBATIMSTRING)
 227         {
 228             os  << token::HASH << token::BEGIN_BLOCK;
 229             os.writeQuoted(t.stringToken(), false);
 230             os  << token::HASH << token::END_BLOCK;
 231         }
 232         else
 233         {
 234             os  << t;
 235         }
 236
 237         if (i < size()-1)
 238         {
 239             os  << token::SPACE;
 240         }
 241     }
 242
 243     if (!contentsOnly)
 244     {
 245         os  << token::END_STATEMENT << endl;
 246     }
 247 }
 248
 249
 250 void Foam::primitiveEntry::write(Ostream& os) const
 251 {
 252     this->write(os, false);
 253 }
 254
 255
 256 // * * * * * * * * * * * * * Ostream operator  * * * * * * * * * * * * * * * //
 257
 258 template<>
 259 Foam::Ostream& Foam::operator<<
 260 (
 261     Ostream& os,
 262     const InfoProxy<primitiveEntry>& ip
 263 )
 264 {
 265     const primitiveEntry& e = ip.t_;
 266
 267     e.print(os);
 268
 269     const label nPrintTokens = 10;
 270
 271     os  << "    primitiveEntry '" << e.keyword() << "' comprises ";
 272
 273     for (label i=0; i<min(e.size(), nPrintTokens); i++)
 274     {
 275         os  << nl << "        " << e[i].info();
 276     }
 277
 278     if (e.size() > nPrintTokens)
 279     {
 280         os  << " ...";
 281     }
 282
 283     os  << endl;
 284
 285     return os;
 286 }
 287
 288
 289 // ************************************************************************* //