functionEntry.H
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration | Website: https://openfoam.org
5  \\ / A nd | Copyright (C) 2011-2022 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 Namespace
25  Foam::functionEntries
26 
27 Description
28  Namespace for containing a functionEntry.
29 
30 
31 Class
32  Foam::functionEntry
33 
34 Description
35  A functionEntry causes entries to be added/manipulated on the specified
36  dictionary given an input stream.
37 
38  In dictionaries, a \c '\#' sigil is typically used for a functionEntry.
39 
40 SourceFiles
41  functionEntry.C
42  functionEntryIO.C
43 
44 \*---------------------------------------------------------------------------*/
45 
46 #ifndef functionEntry_H
47 #define functionEntry_H
48 
49 #include "word.H"
51 #include "primitiveEntry.H"
52 
53 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
54 
55 namespace Foam
56 {
57 
58 class dictionary;
59 
60 /*---------------------------------------------------------------------------*\
61  Class functionEntry Declaration
62 \*---------------------------------------------------------------------------*/
63 
64 class functionEntry
65 :
66  public primitiveEntry
67 {
68  // Private Member Functions
69 
70  //- Read line as word token
71  static token readLine(Istream& is);
72 
73 
74 protected:
75 
76  //- Read the function name and optional argument list
77  // and return as a string.
78  // The optional argument list can be on one or more lines.
79  static string readFuncNameArgs(Istream& is);
80 
81  //- Insert the given string in a sub-dict context
82  static bool insert
83  (
84  dictionary& parentDict,
85  const string&
86  );
87 
88  //- Insert the given string in a primitiveEntry context
89  static bool insert
90  (
91  const dictionary& parentDict,
92  primitiveEntry& thisEntry,
93  const string&
94  );
95 
96 
97 public:
98 
99  // Constructors
100 
101  //- Construct from keyword, parent dictionary and Istream
102  functionEntry(const word&, const dictionary&, Istream&);
103 
104  //- Copy construct
105  functionEntry(const functionEntry&) = default;
106 
107  //- Clone
108  autoPtr<entry> clone(const dictionary&) const
109  {
110  return autoPtr<entry>(new functionEntry(*this));
111  }
112 
113 
114  // Member Function Selectors
115 
117  (
118  bool,
120  execute,
121  dictionaryIstream,
122  (
123  dictionary& parentDict,
124  Istream& is
125  ),
126  (parentDict, is)
127  );
128 
129  //- Execute the functionEntry in a sub-dict context
130  static bool execute
131  (
132  const word& functionName,
133  dictionary& parentDict,
134  Istream&
135  );
136 
138  (
139  bool,
141  execute,
142  primitiveEntryIstream,
143  (
144  const dictionary& parentDict,
146  Istream& is
147  ),
148  (parentDict, entry, is)
149  );
150 
151  //- Execute the functionEntry in a primitiveEntry context
152  static bool execute
153  (
154  const word& functionName,
155  const dictionary& parentDict,
157  Istream&
158  );
159 
160  //- Write
161  virtual void write(Ostream&) const;
162 
163 
164  // Member Operators
165 
166  //- Disallow default bitwise assignment
167  void operator=(const functionEntry&) = delete;
168 };
169 
170 
171 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
172 
173 } // End namespace Foam
174 
175 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
176 
177 #endif
178 
179 // ************************************************************************* //
An Istream is an abstract base class for all input systems (streams, files, token lists etc)....
Definition: Istream.H:60
An Ostream is an abstract base class for all output systems (streams, files, token lists,...
Definition: Ostream.H:57
An auto-pointer similar to the STL auto_ptr but with automatic casting to a reference to the type and...
Definition: autoPtr.H:51
A list of keyword definitions, which are a keyword followed by any number of values (e....
Definition: dictionary.H:162
A keyword and a list of tokens is an 'entry'.
Definition: entry.H:68
virtual autoPtr< entry > clone() const
Construct on freestore as copy.
Definition: entry.C:54
A functionEntry causes entries to be added/manipulated on the specified dictionary given an input str...
Definition: functionEntry.H:66
virtual void write(Ostream &) const
Write.
static bool insert(dictionary &parentDict, const string &)
Insert the given string in a sub-dict context.
static string readFuncNameArgs(Istream &is)
Read the function name and optional argument list.
Definition: functionEntry.C:68
declareMemberFunctionSelectionTable(bool, functionEntry, execute, dictionaryIstream,(dictionary &parentDict, Istream &is),(parentDict, is))
static bool execute(const word &functionName, dictionary &parentDict, Istream &)
Execute the functionEntry in a sub-dict context.
functionEntry(const word &, const dictionary &, Istream &)
Construct from keyword, parent dictionary and Istream.
void operator=(const functionEntry &)=delete
Disallow default bitwise assignment.
A functionName is a word starting with '#'.
Definition: functionName.H:60
A keyword and a list of tokens is a 'primitiveEntry'. An primitiveEntry can be read,...
A token holds items read from Istream.
Definition: token.H:73
A class for handling words, derived from string.
Definition: word.H:62
Namespace for OpenFOAM.