regIOobject.H 6.32 KB
Newer Older
1 2 3 4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
Mark Olesen's avatar
Mark Olesen committed
5
    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
     \\/     M anipulation  |
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

    OpenFOAM is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
    Free Software Foundation; either version 2 of the License, or (at your
    option) any later version.

    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    for more details.

    You should have received a copy of the GNU General Public License
    along with OpenFOAM; if not, write to the Free Software Foundation,
    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Class
    Foam::regIOobject

Description
    regIOobject is an abstract class derived from IOobject to handle
    automatic object registration with the objectRegistry.

SourceFiles
    regIOobject.C
    regIOobjectRead.C
    regIOobjectWrite.C

\*---------------------------------------------------------------------------*/

#ifndef regIOobject_H
#define regIOobject_H

#include "IOobject.H"
#include "typeInfo.H"
#include "OSspecific.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

mattijs's avatar
mattijs committed
48

49 50 51 52
namespace Foam
{

/*---------------------------------------------------------------------------*\
53
                         Class regIOobject Declaration
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
\*---------------------------------------------------------------------------*/

class regIOobject
:
    public IOobject
{

private:

    // Private data

        //- Is this object registered with the registry
        bool registered_;

        //- Is this object owned by the registry
        bool ownedByRegistry_;

        //- Time of last modification
        mutable time_t lastModified_;

mattijs's avatar
mattijs committed
74 75 76
        //- eventNo of last update
        label eventNo_;

77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
        //- Istream for reading
        Istream* isPtr_;


    // Private member functions

        //- Return Istream
        Istream& readStream();

        //- Dissallow assignment
        void operator=(const regIOobject&);


public:

    // Static data

        //- Runtime type information
        TypeName("regIOobject");

        static int fileModificationSkew;


    // Constructors

mattijs's avatar
mattijs committed
102 103 104
        //- Construct from IOobject. Optional flag for if IOobject is the
        //  top level regIOobject.
        regIOobject(const IOobject&, const bool isTime = false);
105 106 107 108

        //- Construct as copy
        regIOobject(const regIOobject&);

Mark Olesen's avatar
Mark Olesen committed
109
        //- Construct as copy, and transferring registry registration to copy
110 111 112 113 114 115 116 117 118 119 120 121 122
        //  if registerCopy is true
        regIOobject(const regIOobject&, bool registerCopy);


    // Destructor

        virtual ~regIOobject();


    // Member functions

        // Registration

123 124
            //- Add object to registry
            bool checkIn();
125

126 127
            //- Remove object from registry
            bool checkOut();
128

129
            //- Is this object owned by the registry?
130 131 132 133 134 135 136 137
            inline bool ownedByRegistry() const;

            //- Transfer ownership of this object to its registry
            inline void store();

            //- Transfer ownership of the given object pointer to its registry
            //  and return reference to object.
            template<class Type>
138
            inline static Type& store(Type*);
139 140 141 142

            //- Transfer ownership of the given object pointer to its registry
            //  and return reference to object.
            template<class Type>
143
            inline static Type& store(autoPtr<Type>&);
144 145 146 147 148

            //- Release ownership of this object from its registry
            inline void release();


mattijs's avatar
mattijs committed
149 150 151 152 153 154 155 156 157
        // Dependency checking

            //- Event number at last update.
            inline label eventNo() const;

            //- Event number at last update.
            inline label& eventNo();

            //- Am I uptodate with respect to other regIOobjects
158 159 160 161 162 163 164 165 166 167 168 169 170 171
            bool upToDate(const word&) const;
            bool upToDate(const word&, const word&) const;
            bool upToDate(const word&, const word&, const word&) const;
            bool upToDate
            (
                const word&,
                const word&,
                const word&,
                const word&
            ) const;

            //- Flag me as up to date
            void setUpToDate();

mattijs's avatar
mattijs committed
172

173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
        // Edit

            //- Rename
            virtual void rename(const word& newName);


        // Reading

            //- Return Istream and check object type against that given
            Istream& readStream(const word&);

            //- Close Istream
            void close();

            //- Virtual readData function.
            //  Must be defined in derived types for which
            //  re-reading is required
            virtual bool readData(Istream&);

            //- Read object
            virtual bool read();

            //- Return true if the object's file has been modified
            virtual bool modified() const;

            //- Read object if modified
            virtual bool readIfModified();


        // Writing

            //- Pure virtual writaData function.
            //  Must be defined in derived types
            virtual bool writeData(Ostream&) const = 0;

            //- Write using given format, version and compression
            virtual bool writeObject
            (
211 212 213
                IOstream::streamFormat,
                IOstream::versionNumber,
                IOstream::compressionType
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
            ) const;

            //- Write using setting from DB
            virtual bool write() const;


    // Member operators

        void operator=(const IOobject&);
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#include "regIOobjectI.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //