src/OpenFOAM/db/regIOobject/regIOobject.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2010 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
  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 \*---------------------------------------------------------------------------*/
  25
  26 #include "regIOobject.H"
  27 #include "Time.H"
  28 #include "polyMesh.H"
  29
  30 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  31
  32 defineTypeNameAndDebug(Foam::regIOobject, 0);
  33
  34 int Foam::regIOobject::fileModificationSkew
  35 (
  36     Foam::debug::optimisationSwitch("fileModificationSkew", 30)
  37 );
  38
  39 namespace Foam
  40 {
  41     template<>
  42     const char* Foam::NamedEnum
  43     <
  44         Foam::regIOobject::fileCheckTypes,
  45         4
  46     >::names[] =
  47     {
  48         "timeStamp",
  49         "timeStampMaster",
  50         "inotify",
  51         "inotifyMaster"
  52     };
  53 }
  54
  55
  56 const Foam::NamedEnum<Foam::regIOobject::fileCheckTypes, 4>
  57     Foam::regIOobject::fileCheckTypesNames;
  58
  59 // Default fileCheck type
  60 Foam::regIOobject::fileCheckTypes Foam::regIOobject::fileModificationChecking
  61 (
  62     fileCheckTypesNames.read
  63     (
  64         debug::optimisationSwitches().lookup
  65         (
  66             "fileModificationChecking"
  67         )
  68     )
  69 );
  70
  71
  72 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  73
  74 // Construct from IOobject
  75 Foam::regIOobject::regIOobject(const IOobject& io, const bool isTime)
  76 :
  77     IOobject(io),
  78     registered_(false),
  79     ownedByRegistry_(false),
  80     watchIndex_(-1),
  81     eventNo_                // Do not get event for top level Time database
  82     (
  83         isTime
  84       ? 0
  85       : db().getEvent()
  86     ),
  87     isPtr_(NULL)
  88 {
  89     // Register with objectRegistry if requested
  90     if (registerObject())
  91     {
  92         checkIn();
  93     }
  94 }
  95
  96
  97 // Construct as copy
  98 Foam::regIOobject::regIOobject(const regIOobject& rio)
  99 :
 100     IOobject(rio),
 101     registered_(false),
 102     ownedByRegistry_(false),
 103     watchIndex_(rio.watchIndex_),
 104     eventNo_(db().getEvent()),
 105     isPtr_(NULL)
 106 {
 107     // Do not register copy with objectRegistry
 108 }
 109
 110
 111 // Construct as copy, and transfering objectRegistry registration to copy
 112 // if registerCopy is true
 113 Foam::regIOobject::regIOobject(const regIOobject& rio, bool registerCopy)
 114 :
 115     IOobject(rio),
 116     registered_(false),
 117     ownedByRegistry_(false),
 118     watchIndex_(-1),
 119     eventNo_(db().getEvent()),
 120     isPtr_(NULL)
 121 {
 122     if (registerCopy && rio.registered_)
 123     {
 124         const_cast<regIOobject&>(rio).checkOut();
 125         checkIn();
 126     }
 127 }
 128
 129
 130 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 131
 132 // Delete read stream, checkout from objectRegistry and destroy
 133 Foam::regIOobject::~regIOobject()
 134 {
 135     if (objectRegistry::debug)
 136     {
 137         Info<< "Destroying regIOobject called " << name()
 138             << " of type " << type()
 139             << " in directory " << path()
 140             << endl;
 141     }
 142
 143     if (isPtr_)
 144     {
 145         delete isPtr_;
 146         isPtr_ = NULL;
 147     }
 148
 149     // Check out of objectRegistry if not owned by the registry
 150
 151     if (!ownedByRegistry_)
 152     {
 153         checkOut();
 154     }
 155 }
 156
 157
 158 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 159
 160 bool Foam::regIOobject::checkIn()
 161 {
 162     if (!registered_)
 163     {
 164         // multiple checkin of same object is disallowed - this would mess up
 165         // any mapping
 166         registered_ = db().checkIn(*this);
 167
 168         if
 169         (
 170             registered_
 171          && readOpt() == MUST_READ_IF_MODIFIED
 172          && time().runTimeModifiable()
 173         )
 174         {
 175             if (watchIndex_ != -1)
 176             {
 177                 FatalErrorIn("regIOobject::checkIn()")
 178                     << "Object " << objectPath()
 179                     << " already watched with index " << watchIndex_
 180                     << abort(FatalError);
 181             }
 182
 183             fileName f = filePath();
 184             if (!f.size())
 185             {
 186                 // We don't have this file but would like to re-read it.
 187                 // Possibly if master-only reading mode.
 188                 f = objectPath();
 189             }
 190             watchIndex_ = time().addWatch(f);
 191         }
 192
 193         // check-in on defaultRegion is allowed to fail, since subsetted meshes
 194         // are created with the same name as their originating mesh
 195         if (!registered_ && debug && name() != polyMesh::defaultRegion)
 196         {
 197             if (debug == 2)
 198             {
 199                 // for ease of finding where attempted duplicate check-in
 200                 // originated
 201                 FatalErrorIn("regIOobject::checkIn()")
 202                     << "failed to register object " << objectPath()
 203                     << " the name already exists in the objectRegistry"
 204                     << abort(FatalError);
 205             }
 206             else
 207             {
 208                 WarningIn("regIOobject::checkIn()")
 209                     << "failed to register object " << objectPath()
 210                     << " the name already exists in the objectRegistry"
 211                     << endl;
 212             }
 213         }
 214     }
 215
 216     return registered_;
 217 }
 218
 219
 220 bool Foam::regIOobject::checkOut()
 221 {
 222     if (registered_)
 223     {
 224         registered_ = false;
 225
 226         if (watchIndex_ != -1)
 227         {
 228             time().removeWatch(watchIndex_);
 229             watchIndex_ = -1;
 230         }
 231         return db().checkOut(*this);
 232     }
 233
 234     return false;
 235 }
 236
 237
 238 bool Foam::regIOobject::upToDate(const regIOobject& a) const
 239 {
 240     if (a.eventNo() >= eventNo_)
 241     {
 242         return false;
 243     }
 244     else
 245     {
 246         return true;
 247     }
 248 }
 249
 250
 251 bool Foam::regIOobject::upToDate
 252 (
 253     const regIOobject& a,
 254     const regIOobject& b
 255 ) const
 256 {
 257     if
 258     (
 259         a.eventNo() >= eventNo_
 260      || b.eventNo() >= eventNo_
 261     )
 262     {
 263         return false;
 264     }
 265     else
 266     {
 267         return true;
 268     }
 269 }
 270
 271
 272 bool Foam::regIOobject::upToDate
 273 (
 274     const regIOobject& a,
 275     const regIOobject& b,
 276     const regIOobject& c
 277 ) const
 278 {
 279     if
 280     (
 281         a.eventNo() >= eventNo_
 282      || b.eventNo() >= eventNo_
 283      || c.eventNo() >= eventNo_
 284     )
 285     {
 286         return false;
 287     }
 288     else
 289     {
 290         return true;
 291     }
 292 }
 293
 294
 295 bool Foam::regIOobject::upToDate
 296 (
 297     const regIOobject& a,
 298     const regIOobject& b,
 299     const regIOobject& c,
 300     const regIOobject& d
 301 ) const
 302 {
 303     if
 304     (
 305         a.eventNo() >= eventNo_
 306      || b.eventNo() >= eventNo_
 307      || c.eventNo() >= eventNo_
 308      || d.eventNo() >= eventNo_
 309     )
 310     {
 311         return false;
 312     }
 313     else
 314     {
 315         return true;
 316     }
 317 }
 318
 319
 320 //- Flag me as up to date
 321 void Foam::regIOobject::setUpToDate()
 322 {
 323     eventNo_ = db().getEvent();
 324 }
 325
 326
 327 // Rename object and re-register with objectRegistry under new name
 328 void Foam::regIOobject::rename(const word& newName)
 329 {
 330     // Check out of objectRegistry
 331     checkOut();
 332
 333     IOobject::rename(newName);
 334
 335     if (registerObject())
 336     {
 337         // Re-register object with objectRegistry
 338         checkIn();
 339     }
 340 }
 341
 342
 343 // Assign to IOobject
 344 void Foam::regIOobject::operator=(const IOobject& io)
 345 {
 346     if (isPtr_)
 347     {
 348         delete isPtr_;
 349         isPtr_ = NULL;
 350     }
 351
 352     // Check out of objectRegistry
 353     checkOut();
 354
 355     IOobject::operator=(io);
 356
 357     if (registerObject())
 358     {
 359         // Re-register object with objectRegistry
 360         checkIn();
 361     }
 362 }
 363
 364
 365 // ************************************************************************* //