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-2020 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&);
104  autoPtr<entry> clone(const dictionary&) const
105  {
106  return autoPtr<entry>(new functionEntry(*this));
107  }
108 
109 
110  // Member Function Selectors
111 
113  (
114  bool,
116  execute,
117  dictionaryIstream,
118  (
119  dictionary& parentDict,
120  Istream& is
121  ),
122  (parentDict, is)
123  );
124 
125  //- Execute the functionEntry in a sub-dict context
126  static bool execute
127  (
128  const word& functionName,
129  dictionary& parentDict,
130  Istream&
131  );
132 
134  (
135  bool,
137  execute,
138  primitiveEntryIstream,
139  (
140  const dictionary& parentDict,
142  Istream& is
143  ),
144  (parentDict, entry, is)
145  );
146 
147  //- Execute the functionEntry in a primitiveEntry context
148  static bool execute
149  (
150  const word& functionName,
151  const dictionary& parentDict,
153  Istream&
154  );
155 
156  //- Write
157  virtual void write(Ostream&) const;
158 
159 
160  // Member Operators
161 
162  //- Disallow default bitwise assignment
163  void operator=(const functionEntry&) = delete;
164 };
165 
166 
167 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
168 
169 } // End namespace Foam
170 
171 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
172 
173 #endif
174 
175 // ************************************************************************* //
functionEntry(const word &, const dictionary &, Istream &)
Construct from keyword, parent dictionary and Istream.
void operator=(const functionEntry &)=delete
Disallow default bitwise assignment.
static bool insert(dictionary &parentDict, const string &)
Insert the given string in a sub-dict context.
A list of keyword definitions, which are a keyword followed by any number of values (e...
Definition: dictionary.H:156
An Istream is an abstract base class for all input systems (streams, files, token lists etc)...
Definition: Istream.H:57
A token holds items read from Istream.
Definition: token.H:72
virtual void write(Ostream &) const
Write.
A keyword and a list of tokens is a &#39;primitiveEntry&#39;. An primitiveEntry can be read, written and printed, and the types and values of its tokens analysed.
A functionName is a word starting with &#39;#&#39;.
Definition: functionName.H:57
A class for handling words, derived from string.
Definition: word.H:59
A functionEntry causes entries to be added/manipulated on the specified dictionary given an input str...
Definition: functionEntry.H:63
static bool execute(const word &functionName, dictionary &parentDict, Istream &)
Execute the functionEntry in a sub-dict context.
declareMemberFunctionSelectionTable(bool, functionEntry, execute, dictionaryIstream,(dictionary &parentDict, Istream &is),(parentDict, is))
An Ostream is an abstract base class for all output systems (streams, files, token lists...
Definition: Ostream.H:54
virtual autoPtr< entry > clone() const
Construct on freestore as copy.
Definition: entry.C:54
static string readFuncNameArgs(Istream &is)
Read the function name and optional argument list.
Definition: functionEntry.C:68
An auto-pointer similar to the STL auto_ptr but with automatic casting to a reference to the type and...
Definition: PtrList.H:52
Namespace for OpenFOAM.
A keyword and a list of tokens is an &#39;entry&#39;.
Definition: entry.H:65