dynamicCode.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Copyright (C) 2011-2026 OpenFOAM Foundation
     \\/     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 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/>.
 
Class
    Foam::dynamicCode
 
Description
    Encapsulation of dynamic code dictionaries and functionality
 
SourceFiles
    dynamicCode.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef dynamicCode_H
#define dynamicCode_H
 
#include "dictionary.H"
#include "HashTable.H"
#include "SHA1Digest.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
/*---------------------------------------------------------------------------*\
                     Class dynamicCode Declaration
\*---------------------------------------------------------------------------*/
 
class dynamicCode
{
    // Private Data
 
        //- Top-level directory name for copy/compiling
        static const word topDirName;
 
        //- Name of the code template sub-directory
        //  Used when locating the codeTemplateName via Foam::findEtcFile
        static const fileName codeTemplateDirName;
 
        //- Root of the LIB target for Make/files
        static const char* const libTargetRoot;
 
        //- Root for dynamic code compilation
        fileName codeRoot_;
 
        //- Subdirectory name for loading libraries
        const fileName libSubDir_;
 
        //- Name for code
        word codeName_;
 
        //- Unique name for code with the SHA1 appendedm
        word codeSha1Name_;
 
        //- Name for code subdirectory
        word codeDirName_;
 
        //- Keywords associated with source code
        const wordList& codeKeys_;
 
        //- Name of the dictionary variables in the source code
        const wordList& codeDictVars_;
 
        //- Options file name
        const word& optionsFileName_;
 
        //- Files to copy and filter and compile
        const wordList& compileFiles_;
 
        //- Files to copy and filter
        const wordList& copyFiles_;
 
        //- Code strings
        //  Stored to write for restart
        List<verbatimString> codeStrings_;
 
        //- Variable substitutions
        HashTable<string> varSubstitutions_;
 
        //- Code key substitutions
        HashTable<string> codeKeySubstitutions_;
 
        //- Optional "codeOptions" string
        //  Stored to write for restart
        verbatimString optionsString_;
 
        //- Optional "codeOptions" entry
        string options_;
 
        //- Optional "codeLibs" string
        //  Stored to write for restart
        verbatimString libsString_;
 
        //- Optional "codeLibs" entry
        string libs_;
 
        //- Calculated SHA1Digest
        SHA1Digest sha1_;
 
 
    // Private Member Functions
 
        //- Path for SHA1Digest
        //  Corresponds to codePath()/Make/SHA1Digest
        fileName digestFile() const
        {
            return codeRoot_/codeDirName_/"Make/SHA1Digest";
        }
 
        //- Path for specified code name
        //  Corresponds to codeRoot()/codeDirName()
        fileName codePath() const
        {
            return codeRoot_/codeDirName_;
        }
 
        //- Path for specified code name relative to \$FOAM_CASE
        //  Corresponds to topDirName/codeDirName()
        fileName codeRelPath() const
        {
            return topDirName/codeDirName_;
        }
 
        //- Add a \#line directive to the start of the given source string that
        //  compilation messages are meaningful
        static void addLineDirective
        (
            string&,
            const label lineNum,
            const fileName& name
        );
 
        //- Copy lines while expanding variables
        static void copyAndFilter
        (
            ISstream&,
            OSstream&,
            const HashTable<string>& mapping
        );
 
        //- Resolve code-templates via Foam::findConfigFile
        static bool resolveTemplates
        (
            const wordList& templateNames,
            DynamicList<fileName>& resolvedFiles,
            DynamicList<fileName>& badFiles
        );
 
        //- Copy/create Make/files prior to compilation
        bool createMakeFiles() const;
 
        //- Copy/create Make/options prior to compilation
        bool createMakeOptions() const;
 
        //- Write digest to Make/SHA1Digest
        bool writeDigest() const;
 
 
public:
 
    // Static Data Members
 
        // Declare name of the class and its debug switch
        ClassName("dynamicCode");
 
        //- Flag if system operations are allowed
        static int allowSystemOperations;
 
 
    // Constructors
 
        //- Construct from the context and code dictionaries
        //  and lists of which entries correspond to code
        dynamicCode
        (
            const dictionary& contextDict,
            const dictionary& codeDict,
            const word& codeName,
            const word& codeDirName,
            const wordList& codeKeys,
            const wordList& codeDictVars,
            const word& optionsFileName,
            const wordList& compileFiles,
            const wordList& copyFiles
        );
 
        //- Construct from the context dictionary also containing the code
        //  and lists of which entries correspond
        dynamicCode
        (
            const dictionary& contextDict,
            const word& codeName,
            const word& codeDirName,
            const wordList& codeKeys,
            const wordList& codeDictVars,
            const word& optionsFileName,
            const wordList& compileFiles,
            const wordList& copyFiles
        );
 
 
    // Member Functions
 
        //- Return the code-name
        const word& codeName() const
        {
            return codeName_;
        }
 
        //- Return the unique code name
        const word& codeSha1Name() const
        {
            return codeSha1Name_;
        }
 
        //- Library path for specified code name
        //  Corresponds to codeRoot()/libSubDir()/lib<codeSha1Name>.so
        fileName libPath() const
        {
            return codeRoot_/libSubDir_/"lib" + codeSha1Name_ + ".so";
        }
 
        //- Library path for specified code name relative to \$FOAM_CASE
        //  Corresponds to
        //  dynamicCode/codeDirName()/libSubDir()/lib<codeSha1Name>.so
        fileName libRelPath() const
        {
            return codeRelPath()/libSubDir_/"lib" + codeSha1Name_ + ".so";
        }
 
        HashTable<string>& varSubstitutions()
        {
            return varSubstitutions_;
        }
 
        //- Return the library basename without leading 'lib' or trailing '.so'
        static word libraryBaseName(const fileName& libPath);
 
        //- Resolve code-template via Foam::findConfigFile
        static fileName resolveTemplate(const fileName& templateName);
 
        //- Verify if the copied code is up-to-date, based on Make/SHA1Digest
        bool upToDate() const;
 
        //- Copy/create files prior to compilation
        bool copyOrCreateFiles(const bool verbose = false) const;
 
        //- Compile a libso
        bool wmakeLibso() const;
 
        void* loadLibrary(const fileName& libPath) const;
 
        void createLibrary
        (
            const dictionary& dict,
            const bool masterOnlyRead = false
        ) const;
 
        void read(const dictionary& contextDict, const dictionary& codeDict);
 
        void read(const dictionary& contextDict);
 
        //- Write the code for restart
        void write(Ostream& os) const;
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //