objectRegistryCache.C

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2019 OpenFOAM Foundation
    Copyright (C) 2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
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 3 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, see <http://www.gnu.org/licenses/>.
 
\*---------------------------------------------------------------------------*/
 
#include "objectRegistry.H"
#include "Time.H"
 
// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
void Foam::objectRegistry::readCacheTemporaryObjects() const
{
    if (cacheTemporaryObjectsActive_) return;
 
    const auto* eptr = time_.controlDict().findEntry
    (
        "cacheTemporaryObjects",
        keyType::LITERAL
    );
 
    if (eptr)
    {
        cacheTemporaryObjectsActive_ = true;
 
        // Clear old cache?
        // cacheTemporaryObjects_.clear();
 
        wordList objectNames;
 
        if (eptr->isDict())
        {
            // Per region (sub-dictionary syntax)
            eptr->dict().readIfPresent(name(), objectNames);
        }
        else
        {
            // All regions
            eptr->readEntry(objectNames);
        }
 
        for (const word& objName : objectNames)
        {
            cacheTemporaryObjects_.emplace(objName, false, false);
        }
 
        if (objectRegistry::debug)
        {
            Info<< "objectRegistry::cacheTemporaryObjects : "
                << flatOutput(objectNames) << endl;
        }
    }
}
 
 
void Foam::objectRegistry::deleteCachedObject(regIOobject* io) const
{
    if (io)
    {
        io->release();     // Relinquish any ownership by registry
        io->checkOut();
        // Additional safety - not certain this is actually needed...
        io->rename(io->name() + "-Cache");
        delete io;
    }
}
 
 
// FUTURE: (currently not needed)
// void Foam::objectRegistry::addTemporaryObject
// (
//     const word& name
// ) const
// {
//     cacheTemporaryObjects_.emplace(name, false, false);
// }
 
 
bool Foam::objectRegistry::is_cacheTemporaryObject
(
    const word& name
) const
{
    return cacheTemporaryObjects_.contains(name);
}
 
 
bool Foam::objectRegistry::is_cacheTemporaryObject(const regIOobject* io) const
{
    return io && cacheTemporaryObjects_.contains(io->name());
}
 
 
bool Foam::objectRegistry::is_cacheTemporaryObject(const regIOobject& io) const
{
    return cacheTemporaryObjects_.contains(io.name());
}
 
 
void Foam::objectRegistry::resetCacheTemporaryObject
(
    const regIOobject* io
) const
{
    if (io && !cacheTemporaryObjects_.empty())
    {
        auto iter = cacheTemporaryObjects_.find(io->name());
 
        // Reset the cached flag
        if (iter.good())
        {
            iter.val().first() = false;
        }
    }
}
 
 
void Foam::objectRegistry::resetCacheTemporaryObject
(
    const regIOobject& io
) const
{
    resetCacheTemporaryObject(&io);
}
 
 
bool Foam::objectRegistry::checkCacheTemporaryObjects() const
{
    bool enabled = cacheTemporaryObjects_.size();
 
    forAllConstIters(*this, iter)
    {
        const auto* subObr = dynamic_cast<const objectRegistry*>(iter.val());
 
        // Protect against re-searching the top-level registry
        if (subObr && subObr != this)
        {
            enabled = subObr->checkCacheTemporaryObjects() || enabled;
        }
    }
 
    if (enabled)
    {
        OSstream* emitWarning = nullptr;
 
        forAllIters(cacheTemporaryObjects_, iter)
        {
            if (!iter.val().second())
            {
                if (!emitWarning)
                {
                    emitWarning = &(Foam::Warning.stream());
 
                    *emitWarning
                        << "objectRegistry '"
                        << name() << "' has missing temporary objects:" << nl;
                }
 
                *emitWarning<< "    " << iter.key() << nl;
            }
            else
            {
                iter.val().second() = false;
            }
        }
 
        if (emitWarning)
        {
            *emitWarning
                << "Available temporary objects: "
                << temporaryObjects_.sortedToc() << endl;
        }
 
        temporaryObjects_.clear();
    }
 
    return enabled;
}
 
 
// ************************************************************************* //