src/OpenFOAM/db/regIOobject/regIOobject.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::regIOobject
  26
  27 Description
  28     regIOobject is an abstract class derived from IOobject to handle
  29     automatic object registration with the objectRegistry.
  30
  31 SourceFiles
  32     regIOobject.C
  33     regIOobjectRead.C
  34     regIOobjectWrite.C
  35
  36 \*---------------------------------------------------------------------------*/
  37
  38 #ifndef regIOobject_H
  39 #define regIOobject_H
  40
  41 #include "IOobject.H"
  42 #include "typeInfo.H"
  43 #include "OSspecific.H"
  44 #include "NamedEnum.H"
  45
  46 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  47
  48
  49 namespace Foam
  50 {
  51
  52 /*---------------------------------------------------------------------------*\
  53                          Class regIOobject Declaration
  54 \*---------------------------------------------------------------------------*/
  55
  56 class regIOobject
  57 :
  58     public IOobject
  59 {
  60
  61 public:
  62
  63     //- Types of communications
  64     enum fileCheckTypes
  65     {
  66         timeStamp,
  67         timeStampMaster,
  68         inotify,
  69         inotifyMaster
  70     };
  71
  72     static const NamedEnum<fileCheckTypes, 4> fileCheckTypesNames;
  73
  74
  75 private:
  76
  77     // Private data
  78
  79         //- Is this object registered with the registry
  80         bool registered_;
  81
  82         //- Is this object owned by the registry
  83         bool ownedByRegistry_;
  84
  85         //- Modification watch index
  86         mutable label watchIndex_;
  87
  88         //- eventNo of last update
  89         label eventNo_;
  90
  91         //- Istream for reading
  92         Istream* isPtr_;
  93
  94
  95     // Private Member Functions
  96
  97         //- Return Istream
  98         Istream& readStream();
  99
 100         //- Dissallow assignment
 101         void operator=(const regIOobject&);
 102
 103
 104 public:
 105
 106     // Static data
 107
 108         //- Runtime type information
 109         TypeName("regIOobject");
 110
 111         static int fileModificationSkew;
 112
 113         static fileCheckTypes fileModificationChecking;
 114
 115
 116     // Constructors
 117
 118         //- Construct from IOobject. Optional flag for if IOobject is the
 119         //  top level regIOobject.
 120         regIOobject(const IOobject&, const bool isTime = false);
 121
 122         //- Construct as copy
 123         regIOobject(const regIOobject&);
 124
 125         //- Construct as copy, and transferring registry registration to copy
 126         //  if registerCopy is true
 127         regIOobject(const regIOobject&, bool registerCopy);
 128
 129
 130     //- Destructor
 131     virtual ~regIOobject();
 132
 133
 134     // Member functions
 135
 136         // Registration
 137
 138             //- Add object to registry
 139             bool checkIn();
 140
 141             //- Remove object from registry
 142             bool checkOut();
 143
 144             //- Is this object owned by the registry?
 145             inline bool ownedByRegistry() const;
 146
 147             //- Transfer ownership of this object to its registry
 148             inline void store();
 149
 150             //- Transfer ownership of the given object pointer to its registry
 151             //  and return reference to object.
 152             template<class Type>
 153             inline static Type& store(Type*);
 154
 155             //- Transfer ownership of the given object pointer to its registry
 156             //  and return reference to object.
 157             template<class Type>
 158             inline static Type& store(autoPtr<Type>&);
 159
 160             //- Release ownership of this object from its registry
 161             inline void release();
 162
 163
 164         // Dependency checking
 165
 166             //- Event number at last update.
 167             inline label eventNo() const;
 168
 169             //- Event number at last update.
 170             inline label& eventNo();
 171
 172             //- Return true if up-to-date with respect to given object
 173             //  otherwise false
 174             bool upToDate(const regIOobject&) const;
 175
 176             //- Return true if up-to-date with respect to given objects
 177             //  otherwise false
 178             bool upToDate
 179             (
 180                 const regIOobject&,
 181                 const regIOobject&
 182             ) const;
 183
 184             //- Return true if up-to-date with respect to given objects
 185             //  otherwise false
 186             bool upToDate
 187             (
 188                 const regIOobject&,
 189                 const regIOobject&,
 190                 const regIOobject&
 191             ) const;
 192
 193             //- Return true if up-to-date with respect to given objects
 194             //  otherwise false
 195             bool upToDate
 196             (
 197                 const regIOobject&,
 198                 const regIOobject&,
 199                 const regIOobject&,
 200                 const regIOobject&
 201             ) const;
 202
 203             //- Set up to date (obviously)
 204             void setUpToDate();
 205
 206
 207         // Edit
 208
 209             //- Rename
 210             virtual void rename(const word& newName);
 211
 212
 213         // Reading
 214
 215             //- Return Istream and check object type against that given
 216             Istream& readStream(const word&);
 217
 218             //- Close Istream
 219             void close();
 220
 221             //- Virtual readData function.
 222             //  Must be defined in derived types for which
 223             //  re-reading is required
 224             virtual bool readData(Istream&);
 225
 226             //- Read object
 227             virtual bool read();
 228
 229             //- Return file-monitoring handle
 230             inline label watchIndex() const;
 231
 232             //- Return file-monitoring handle
 233             inline label& watchIndex();
 234
 235             //- Return true if the object's file (or files for objectRegistry)
 236             //  have been modified. (modified state is cached by Time)
 237             virtual bool modified() const;
 238
 239             //- Read object if modified (as set by call to modified)
 240             virtual bool readIfModified();
 241
 242
 243         // Writing
 244
 245             //- Pure virtual writaData function.
 246             //  Must be defined in derived types
 247             virtual bool writeData(Ostream&) const = 0;
 248
 249             //- Write using given format, version and compression
 250             virtual bool writeObject
 251             (
 252                 IOstream::streamFormat,
 253                 IOstream::versionNumber,
 254                 IOstream::compressionType
 255             ) const;
 256
 257             //- Write using setting from DB
 258             virtual bool write() const;
 259
 260
 261     // Member operators
 262
 263         void operator=(const IOobject&);
 264 };
 265
 266
 267 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 268
 269 } // End namespace Foam
 270
 271 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 272
 273 #include "regIOobjectI.H"
 274
 275 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 276
 277 #endif
 278
 279 // ************************************************************************* //