src/OpenFOAM/db/dictionary/dictionaryIO.C

   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 "dictionary.H"
  28 #include "IFstream.H"
  29 #include "inputModeEntry.H"
  30 #include "regExp.H"
  31
  32 // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
  33
  34 bool Foam::dictionary::read(Istream& is)
  35 {
  36     if (!is.good())
  37     {
  38         FatalIOErrorIn("dictionary::read(Istream&, const word&)", is)
  39             << "Istream not OK for reading dictionary "
  40             << exit(FatalIOError);
  41
  42         return false;
  43     }
  44
  45     token currToken(is);
  46     if (currToken != token::BEGIN_BLOCK)
  47     {
  48         is.putBack(currToken);
  49     }
  50
  51     while (!is.eof() && entry::New(*this, is))
  52     {}
  53
  54     // Remove the FoamFile header entry if it exists
  55     remove("FoamFile");
  56
  57     if (is.bad())
  58     {
  59         Info<< "dictionary::read(Istream&, const word&) : "
  60             << "Istream not OK after reading dictionary " << name()
  61             << endl;
  62
  63         return false;
  64     }
  65
  66     return true;
  67 }
  68
  69
  70 bool Foam::dictionary::substituteKeyword(const word& keyword)
  71 {
  72     word varName = keyword(1, keyword.size()-1);
  73
  74     // lookup the variable name in the given dictionary
  75     const entry* ePtr = lookupEntryPtr(varName, true, true);
  76
  77     // if defined insert its entries into this dictionary
  78     if (ePtr != NULL)
  79     {
  80         const dictionary& addDict = ePtr->dict();
  81
  82         forAllConstIter(IDLList<entry>, addDict, iter)
  83         {
  84             add(iter());
  85         }
  86
  87         return true;
  88     }
  89
  90     return false;
  91 }
  92
  93
  94 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  95
  96 Foam::dictionary::dictionary
  97 (
  98     const dictionary& parentDict,
  99     Istream& is
 100 )
 101 :
 102     name_(is.name()),
 103     parent_(parentDict)
 104 {
 105     read(is);
 106 }
 107
 108
 109 Foam::dictionary::dictionary(Istream& is)
 110 :
 111     name_(is.name()),
 112     parent_(dictionary::null)
 113 {
 114     // Reset input mode as this is a "top-level" dictionary
 115     functionEntries::inputModeEntry::clear();
 116
 117     read(is);
 118 }
 119
 120
 121 Foam::autoPtr<Foam::dictionary> Foam::dictionary::New(Istream& is)
 122 {
 123     return autoPtr<dictionary>(new dictionary(is));
 124 }
 125
 126
 127 // * * * * * * * * * * * * * * Istream Operator  * * * * * * * * * * * * * * //
 128
 129 Foam::Istream& Foam::operator>>(Istream& is, dictionary& dict)
 130 {
 131     // Reset input mode assuming this is a "top-level" dictionary
 132     functionEntries::inputModeEntry::clear();
 133
 134     dict.clear();
 135     dict.read(is);
 136
 137     return is;
 138 }
 139
 140
 141 // * * * * * * * * * * * * * * Ostream Operator  * * * * * * * * * * * * * * //
 142
 143 void Foam::dictionary::write(Ostream& os, bool subDict) const
 144 {
 145     if (subDict)
 146     {
 147         os << nl << indent << token::BEGIN_BLOCK << incrIndent << nl;
 148     }
 149
 150     forAllConstIter(IDLList<entry>, *this, iter)
 151     {
 152         const entry& e = *iter;
 153
 154         // Write entry
 155         os << e;
 156
 157         // Add extra new line between entries for "top-level" dictionaries
 158         if (!subDict && parent() == dictionary::null && e != *last())
 159         {
 160             os << nl;
 161         }
 162
 163         // Check stream before going to next entry.
 164         if (!os.good())
 165         {
 166             WarningIn("dictionary::write(Ostream&, bool subDict)")
 167                 << "Can't write entry " << iter().keyword()
 168                 << " for dictionary " << name()
 169                 << endl;
 170         }
 171     }
 172
 173     if (subDict)
 174     {
 175         os << decrIndent << indent << token::END_BLOCK << endl;
 176     }
 177 }
 178
 179
 180 Foam::Ostream& Foam::operator<<(Ostream& os, const dictionary& dict)
 181 {
 182     dict.write(os, true);
 183     return os;
 184 }
 185
 186
 187 // ************************************************************************* //