src/OpenFOAM/db/IOobject/IOobject.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 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 "IOobject.H"
  28 #include "Time.H"
  29 #include "IFstream.H"
  30
  31 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  32
  33 namespace Foam
  34 {
  35     defineTypeNameAndDebug(IOobject, 0);
  36 }
  37
  38 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  39
  40 Foam::IOobject::IOobject
  41 (
  42     const word& name,
  43     const fileName& instance,
  44     const objectRegistry& registry,
  45     readOption ro,
  46     writeOption wo,
  47     bool registerObject
  48 )
  49 :
  50     name_(name),
  51     headerClassName_(typeName),
  52     note_(),
  53     instance_(instance),
  54     local_(),
  55     db_(registry),
  56     rOpt_(ro),
  57     wOpt_(wo),
  58     registerObject_(registerObject),
  59     objState_(GOOD)
  60 {
  61     if (objectRegistry::debug)
  62     {
  63         Info<< "Constructing IOobject called " << name_
  64             << " of type " << headerClassName_
  65             << endl;
  66     }
  67 }
  68
  69
  70 Foam::IOobject::IOobject
  71 (
  72     const word& name,
  73     const fileName& instance,
  74     const fileName& local,
  75     const objectRegistry& registry,
  76     readOption ro,
  77     writeOption wo,
  78     bool registerObject
  79 )
  80 :
  81     name_(name),
  82     headerClassName_(typeName),
  83     note_(),
  84     instance_(instance),
  85     local_(local),
  86     db_(registry),
  87     rOpt_(ro),
  88     wOpt_(wo),
  89     registerObject_(registerObject),
  90     objState_(GOOD)
  91 {
  92     if (objectRegistry::debug)
  93     {
  94         Info<< "Constructing IOobject called " << name_
  95             << " of type " << headerClassName_
  96             << endl;
  97     }
  98 }
  99
 100
 101 // * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * * //
 102
 103 Foam::IOobject::~IOobject()
 104 {}
 105
 106
 107 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 108
 109 const Foam::objectRegistry& Foam::IOobject::db() const
 110 {
 111     return db_;
 112 }
 113
 114
 115 const Foam::Time& Foam::IOobject::time() const
 116 {
 117     return db_.time();
 118 }
 119
 120
 121 const Foam::fileName& Foam::IOobject::caseName() const
 122 {
 123     return time().caseName();
 124 }
 125
 126
 127 const Foam::fileName& Foam::IOobject::rootPath() const
 128 {
 129     return time().rootPath();
 130 }
 131
 132
 133 Foam::fileName Foam::IOobject::path() const
 134 {
 135     return rootPath()/caseName()/instance()/db_.dbDir()/local();
 136 }
 137
 138
 139 Foam::fileName Foam::IOobject::path
 140 (
 141     const word& instance,
 142     const fileName& local
 143 ) const
 144 {
 145     return rootPath()/caseName()/instance/db_.dbDir()/local;
 146 }
 147
 148
 149 Foam::fileName Foam::IOobject::filePath() const
 150 {
 151     fileName path = this->path();
 152     fileName objectPath = path/name();
 153
 154     if (file(objectPath))
 155     {
 156         return objectPath;
 157     }
 158     else
 159     {
 160         if
 161         (
 162             time().processorCase()
 163          && (
 164                 instance() == time().system()
 165              || instance() == time().constant()
 166             )
 167         )
 168         {
 169             fileName parentObjectPath =
 170                 rootPath()/caseName()
 171                /".."/instance()/db_.dbDir()/local()/name();
 172
 173             if (file(parentObjectPath))
 174             {
 175                 return parentObjectPath;
 176             }
 177         }
 178
 179         if (!dir(path))
 180         {
 181             word newInstancePath = time().findInstancePath(instant(instance()));
 182
 183             if (newInstancePath.size())
 184             {
 185                 fileName fName
 186                 (
 187                     rootPath()/caseName()
 188                    /newInstancePath/db_.dbDir()/local()/name()
 189                 );
 190
 191                 if (file(fName))
 192                 {
 193                     return fName;
 194                 }
 195             }
 196         }
 197     }
 198
 199     return fileName::null;
 200 }
 201
 202
 203 Foam::Istream* Foam::IOobject::objectStream()
 204 {
 205     fileName fName = filePath();
 206
 207     if (fName != fileName::null)
 208     {
 209         IFstream* isPtr = new IFstream(fName);
 210
 211         if (isPtr->good())
 212         {
 213             return isPtr;
 214         }
 215         else
 216         {
 217             delete isPtr;
 218             return NULL;
 219         }
 220     }
 221     else
 222     {
 223         return NULL;
 224     }
 225 }
 226
 227
 228 bool Foam::IOobject::headerOk()
 229 {
 230     bool ok = true;
 231
 232     Istream* isPtr = objectStream();
 233
 234     // If the stream has failed return
 235     if (!isPtr)
 236     {
 237         if (objectRegistry::debug)
 238         {
 239             Info
 240                 << "IOobject::headerOk() : "
 241                 << "file " << objectPath() << " could not be opened"
 242                 << endl;
 243         }
 244
 245         ok = false;
 246     }
 247     else
 248     {
 249         // Try reading header
 250         if (!readHeader(*isPtr))
 251         {
 252             if (objectRegistry::debug)
 253             {
 254                 IOWarningIn("IOobject::headerOk()", (*isPtr))
 255                     << "failed to read header of file " << objectPath()
 256                     << endl;
 257             }
 258
 259             ok = false;
 260         }
 261     }
 262
 263     delete isPtr;
 264
 265     return ok;
 266 }
 267
 268
 269 void Foam::IOobject::setBad(const string& s)
 270 {
 271     if (objState_ != GOOD)
 272     {
 273         FatalErrorIn("IOobject::setBad(const string&)")
 274             << "recurrent failure for object " << s
 275             << exit(FatalError);
 276     }
 277
 278     if (error::level)
 279     {
 280         Info<< "IOobject::setBad(const string&) : "
 281             << "broken object " << s << info() << endl;
 282     }
 283
 284     objState_ = BAD;
 285 }
 286
 287
 288 void Foam::IOobject::operator=(const IOobject& io)
 289 {
 290     name_ = io.name_;
 291     headerClassName_ = io.headerClassName_;
 292     note_ = io.note_;
 293     instance_ = io.instance_;
 294     local_ = io.local_;
 295     rOpt_ = io.rOpt_;
 296     wOpt_ = io.wOpt_;
 297     objState_ = io.objState_;
 298 }
 299
 300
 301 // ************************************************************************* //