IOobjectList.H
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | www.openfoam.com
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8  Copyright (C) 2011-2016 OpenFOAM Foundation
9  Copyright (C) 2016-2018 OpenCFD Ltd.
10 -------------------------------------------------------------------------------
11 License
12  This file is part of OpenFOAM.
13 
14  OpenFOAM is free software: you can redistribute it and/or modify it
15  under the terms of the GNU General Public License as published by
16  the Free Software Foundation, either version 3 of the License, or
17  (at your option) any later version.
18 
19  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
20  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
21  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22  for more details.
23 
24  You should have received a copy of the GNU General Public License
25  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
26 
27 Class
28  Foam::IOobjectList
29 
30 Description
31  List of IOobjects with searching and retrieving facilities.
32 
33 SourceFiles
34  IOobjectList.C
35  IOobjectListTemplates.C
36 
37 \*---------------------------------------------------------------------------*/
38 
39 #ifndef IOobjectList_H
40 #define IOobjectList_H
41 
42 #include "HashPtrTable.H"
43 #include "HashSet.H"
44 #include "IOobject.H"
45 #include "wordRes.H"
46 
47 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
48 
49 namespace Foam
50 {
51 
52 /*---------------------------------------------------------------------------*\
53  Class IOobjectList Declaration
54 \*---------------------------------------------------------------------------*/
55 
56 class IOobjectList
57 :
58  public HashPtrTable<IOobject>
59 {
60  // Private Member Functions
61 
62  //- Check name consistency on all processors
63  //
64  // With syncPar = true, check that object names are the same on
65  // all processors. Trigger FatalError if not.
66  //
67  // When syncPar is used, the object names are sorted as a side-effect,
68  // since this is required for consistent ordering across processors.
69  static bool checkNames(wordList& masterNames, const bool syncPar);
70 
71  //- Combine names from all processors and sort
72  static void syncNames(wordList& objNames);
73 
74  //- Templated implementation for classes()
75  template<class MatchPredicate>
76  static HashTable<wordHashSet> classesImpl
77  (
78  const IOobjectList& list,
79  const MatchPredicate& matchName
80  );
81 
82  //- Templated implementation for count()
83  // The number of items with a matching class
84  template<class MatchPredicate1, class MatchPredicate2>
85  static label countImpl
86  (
87  const IOobjectList& list,
88  const MatchPredicate1& matchClass,
89  const MatchPredicate2& matchName
90  );
91 
92  //- Templated implementation for count()
93  template<class Type, class MatchPredicate>
94  static label countTypeImpl
95  (
96  const IOobjectList& list,
97  const MatchPredicate& matchName
98  );
99 
100  //- Templated implementation for names(), sortedNames()
101  template<class MatchPredicate1, class MatchPredicate2>
102  static wordList namesImpl
103  (
104  const IOobjectList& list,
105  const MatchPredicate1& matchClass,
106  const MatchPredicate2& matchName,
107  const bool doSort
108  );
109 
110  //- Templated implementation for names(), sortedNames()
111  template<class Type, class MatchPredicate>
112  static wordList namesTypeImpl
113  (
114  const IOobjectList& list,
115  const MatchPredicate& matchName,
116  const bool doSort
117  );
118 
119  //- Templated implementation for lookup()
120  template<class MatchPredicate>
121  static IOobjectList lookupImpl
122  (
123  const IOobjectList& list,
124  const MatchPredicate& matchName
125  );
126 
127  //- Templated implementation for lookupClass()
128  template<class MatchPredicate1, class MatchPredicate2>
129  static IOobjectList lookupClassImpl
130  (
131  const IOobjectList& list,
132  const MatchPredicate1& matchClass,
133  const MatchPredicate2& matchName
134  );
135 
136  //- Templated implementation for lookupClass()
137  template<class Type, class MatchPredicate>
138  static IOobjectList lookupClassTypeImpl
139  (
140  const IOobjectList& list,
141  const MatchPredicate& matchName
142  );
143 
144 
145 public:
146 
147  // Constructors
148 
149  //- Construct null with default (128) table capacity
150  IOobjectList();
151 
152  //- Construct given initial table capacity
153  explicit IOobjectList(const label nObjects);
154 
155  //- Copy construct
156  IOobjectList(const IOobjectList& list);
157 
158  //- Move construct
159  IOobjectList(IOobjectList&& list);
160 
161  //- Construct from objectRegistry and instance path
163  (
164  const objectRegistry& db,
165  const fileName& instance,
166  const fileName& local = "",
169  bool registerObject = true
170  );
171 
172 
173  //- Destructor
174  ~IOobjectList() = default;
175 
176 
177  // Member Functions
178 
179  // Basic methods
180 
181  //- Add IOobject to the list
182  bool add(autoPtr<IOobject>& objectPtr);
183 
184  //- Add IOobject to the list
185  bool add(autoPtr<IOobject>&& objectPtr);
186 
187  //- Copy append objects from other to this list, but do not overwrite
188  //- existing keys.
189  //
190  // \return number of items added
191  label append(const IOobjectList& other);
192 
193  //- Move append objects from other to this list, but do not overwrite
194  //- existing keys.
195  // After calling this, the other parameter will contains any items
196  // that could not be moved.
197  //
198  // \return number of items added
199  label append(IOobjectList&& other);
200 
201  //- Remove IOobject from the list, by name or by iterator.
202  //
203  // \return autoPtr<IOobject>
205 
206  //- Remove IOobject from the list.
207  //
208  // \return True if object was removed
209  bool remove(const IOobject& io);
210 
211 
212  // Lookup single item
213 
214  //- Return const pointer to the object found by name
215  // \return IOobject ptr if found else nullptr
216  const IOobject* cfindObject(const word& objName) const;
217 
218  //- Return const pointer to the object found by name that also
219  //- has headerClassName == Type::typeName
220  // \return IOobject ptr if found and the correct type, else nullptr
221  //
222  // \note If \a Type is \c void, no headerClassName check is used
223  // (always true).
224  template<class Type>
225  const IOobject* cfindObject(const word& objName) const;
226 
227  //- Return const pointer to the object found by name
228  // \return IOobject ptr if found else nullptr
229  const IOobject* findObject(const word& objName) const;
230 
231  //- Return const pointer to the object found by name that also
232  //- has headerClassName == Type::typeName
233  // \return IOobject ptr if found and the correct type, else nullptr
234  //
235  // \note If \a Type is \c void, no headerClassName check is used
236  // (always true).
237  template<class Type>
238  const IOobject* findObject(const word& objName) const;
239 
240  //- Return non-const pointer to the object found by name
241  // \return IOobject ptr if found else nullptr
242  IOobject* findObject(const word& objName);
243 
244  //- Return non-const pointer to the object found by name that also
245  //- has headerClassName == Type::typeName
246  // \return IOobject ptr if found and the correct type, else nullptr
247  //
248  // \note If \a Type is \c void, no headerClassName check is used
249  // (always true).
250  template<class Type>
251  IOobject* findObject(const word& objName);
252 
253  //- Return non-const pointer to the object found by name,
254  //- using a const-cast to have it behave like a mutable.
255  // Exercise caution when using.
256  // \return IOobject ptr if found else nullptr
257  IOobject* getObject(const word& objName) const;
258 
259  //- Return non-const pointer to the object found by name that also
260  //- has headerClassName == Type::typeName,
261  //- using a const-cast to have it behave like a mutable.
262  // Exercise caution when using.
263  // \return IOobject ptr if found and the correct type, else nullptr
264  //
265  // \note If \a Type is \c void, no headerClassName check is used
266  // (always true).
267  template<class Type>
268  IOobject* getObject(const word& objName) const;
269 
270 
271  // Lookup multiple items
272 
273  //- The list of IOobjects that have a matching object name.
274  template<class MatchPredicate>
275  IOobjectList lookup(const MatchPredicate& matchName) const;
276 
277  //- The list of IOobjects with the given headerClassName
278  IOobjectList lookupClass(const char* clsName) const;
279 
280  //- The list of IOobjects with matching headerClassName
281  template<class MatchPredicate>
282  IOobjectList lookupClass(const MatchPredicate& matchClass) const;
283 
284  //- The list of IOobjects with matching headerClassName
285  //- that also have a matching object name.
286  template<class MatchPredicate1, class MatchPredicate2>
288  (
289  const MatchPredicate1& matchClass,
290  const MatchPredicate2& matchName
291  ) const;
292 
293  //- The list of IOobjects with headerClassName == Type::typeName
294  //
295  // \note If \a Type is \c void, no headerClassName check is used
296  // (always true).
297  template<class Type>
298  IOobjectList lookupClass() const;
299 
300  //- The list of IOobjects with headerClassName == Type::typeName
301  //- that also have a matching object name.
302  template<class Type, class MatchPredicate>
303  IOobjectList lookupClass(const MatchPredicate& matchName) const;
304 
305 
306  // Summary of classes
307 
308  //- A summary hash of classes used and their associated object names.
309  // The HashTable representation allows us to leverage various
310  // HashTable methods.
311  // This hashed summary view can be useful when querying particular
312  // aspects. For example,
313  //
314  // \code
315  // IOobjectList objects(runTime, runTime.timeName());
316  // HashTable<wordHashSet> classes = objects.classes();
317  //
318  // // How many volScalarField?
319  // word checkType = volScalarField::typeName;
320  //
321  // Info<< checkType << "="
322  // << (classes.found(checkType) ? classes[checkType].size() : 0)
323  // << nl;
324  // \endcode
325  // Using the two-parameter HashTable::lookup method lets us avoid
326  // the \c '?' ternary, but still looks fairly ugly:
327  // \code
328  // Info<< checkType << "="
329  // << classes.lookup(checkType, wordHashSet()).size() << nl;
330  // \endcode
331  //
332  // If we have non-const access to the hash table, and don't mind
333  // incidentally creating empty entries,
334  // we can use the HashTable::operator() directly:
335  // \code
336  // Info<< checkType << "=" << classes(checkType).size() << nl;
337  // \endcode
338  //
339  // Of course, for a single query it would have been easier
340  // and simpler to have used a direct query of the names:
341  // \code
342  // Info<< checkType << "=" << objects.names(checkType).size() << nl;
343  // \endcode
344  //
345  // The summary hash, however, becomes most useful when reducing
346  // the objects in consideration to a particular subset. For example,
347  // \code
348  // const wordHashSet interestingTypes
349  // {
350  // volScalarField::typeName,
351  // volVectorField::typeName
352  // };
353  //
354  // classes.retain(interestingTypes);
355  // \endcode
356  // Or do just the opposite:
357  // \code
358  // classes.erase(unsupportedTypes);
359  // \endcode
360  // This also works with a hashedWordList, since it provides the
361  // expected '()' operator. But in this case the more general
362  // HashTable::filterKeys is required:
363  // \code
364  // const hashedWordList interestingTypes
365  // {
366  // volScalarField::typeName,
367  // volVectorField::typeName
368  // };
369  //
370  // classes.filterKeys(interestingTypes);
371  // \endcode
372  //
373  // Of course, there are many other ways to use and manipulate the
374  // summary information.
375  //
376  // \return HashTable of class-names for keys and wordHashSet of
377  // of object-names for the values.
379 
380  //- A summary hash of classes used and their associated object names,
381  //- restricted to objects that have a matching object name.
382  template<class MatchPredicate>
383  HashTable<wordHashSet> classes(const MatchPredicate& matchName) const;
384 
385 
386  // Number of items
387 
388  //- The number of objects of the given headerClassName
389  // \note uses the class type() method
390  label count(const char* clsName) const;
391 
392  //- The number of objects of the given headerClassName
393  template<class MatchPredicate>
394  label count
395  (
396  const MatchPredicate& matchClass
397  ) const;
398 
399  //- The number of objects of the given headerClassName
400  //- that also have a matching object name.
401  template<class MatchPredicate1, class MatchPredicate2>
402  label count
403  (
404  const MatchPredicate1& matchClass,
405  const MatchPredicate2& matchName
406  ) const;
407 
408  //- The number of objects with headerClassName == Type::typeName
409  template<class Type>
410  label count() const;
411 
412  //- The number of objects with headerClassName == Type::typeName
413  //- that also have a matching object name.
414  //
415  // \note If \a Type is \c void, no headerClassName check is used
416  // (always true).
417  template<class Type, class MatchPredicate>
418  label count(const MatchPredicate& matchName) const;
419 
420 
421  // Summary of names
422 
423  //- The names of the IOobjects
424  wordList names() const;
425 
426  //- The names of the IOobjects.
427  // With syncPar = true, sorts the names and triggers FatalError
428  // if the names are not consistent on all processors.
429  wordList names(const bool syncPar) const;
430 
431  //- The names of IOobjects with the given headerClassName
432  wordList names(const char* clsName) const;
433 
434  //- The names of the IOobjects with the given headerClassName
435  // With syncPar = true, sorts the names and triggers FatalError
436  // if the names are not consistent on all processors.
437  wordList names(const char* clsName, const bool syncPar) const;
438 
439  //- The names of IOobjects with the given headerClassName
440  template<class MatchPredicate>
441  wordList names(const MatchPredicate& matchClass) const;
442 
443  //- The names of the IOobjects with the given headerClassName
444  // With syncPar = true, sorts the names and triggers FatalError
445  // if the names are not consistent on all processors.
446  template<class MatchPredicate>
448  (
449  const MatchPredicate& matchClass,
450  const bool syncPar
451  ) const;
452 
453  //- The names of IOobjects with the given headerClassName
454  //- that also have a matching object name.
455  template<class MatchPredicate1, class MatchPredicate2>
457  (
458  const MatchPredicate1& matchClass,
459  const MatchPredicate2& matchName
460  ) const;
461 
462  //- The names of the IOobjects with the given headerClassName
463  //- that also have a matching object name.
464  // With syncPar = true, sorts the names and triggers FatalError
465  // if the names are not consistent on all processors.
466  template<class MatchPredicate1, class MatchPredicate2>
468  (
469  const MatchPredicate1& matchClass,
470  const MatchPredicate2& matchName,
471  const bool syncPar
472  ) const;
473 
474 
475  //- The names of objects with headerClassName == Type::typeName
476  template<class Type>
477  wordList names() const;
478 
479  //- The names of objects with headerClassName == Type::typeName
480  // With syncPar = true, sorts the names and triggers FatalError
481  // if the names are not consistent on all processors.
482  template<class Type>
483  wordList names(bool syncPar) const;
484 
485  //- The names of objects with headerClassName == Type::typeName
486  //- that also have a matching object name.
487  // With syncPar = true, sorts the names and triggers FatalError
488  // if the names are not consistent on all processors.
489  template<class Type, class MatchPredicate>
490  wordList names(const MatchPredicate& matchName) const;
491 
492  //- The names of objects with headerClassName == Type::typeName
493  //- that also have a matching object name.
494  // With syncPar = true, sorts the names and triggers FatalError
495  // if the names are not consistent on all processors.
496  template<class Type, class MatchPredicate>
498  (
499  const MatchPredicate& matchName,
500  const bool syncPar
501  ) const;
502 
503 
504  // Summary of names (sorted)
505 
506  //- The sorted names of the IOobjects
507  wordList sortedNames() const;
508 
509  //- The sorted names of the IOobjects.
510  // With syncPar = true, sorts the names and triggers FatalError
511  // if the names are not consistent on all processors.
512  wordList sortedNames(const bool syncPar) const;
513 
514  //- The sorted names of IOobjects with the given headerClassName
515  wordList sortedNames(const char* clsName) const;
516 
517  //- The sorted names of the IOobjects with the given headerClassName
518  // With syncPar = true, sorts the names and triggers FatalError
519  // if the names are not consistent on all processors.
520  wordList sortedNames(const char* clsName, const bool syncPar) const;
521 
522  //- The sorted names of IOobjects with the given headerClassName
523  template<class MatchPredicate>
524  wordList sortedNames(const MatchPredicate& matchClass) const;
525 
526  //- The sorted names of the IOobjects with the given headerClassName
527  // With syncPar = true, sorts the names and triggers FatalError
528  // if the names are not consistent on all processors.
529  template<class MatchPredicate>
531  (
532  const MatchPredicate& matchClass,
533  const bool syncPar
534  ) const;
535 
536  //- The sorted names of IOobjects with the given headerClassName
537  //- that also have a matching object name.
538  template<class MatchPredicate1, class MatchPredicate2>
540  (
541  const MatchPredicate1& matchClass,
542  const MatchPredicate2& matchName
543  ) const;
544 
545  //- The sorted names of the IOobjects with the given headerClassName
546  //- that also have a matching object name.
547  // With syncPar = true, sorts the names and triggers FatalError
548  // if the names are not consistent on all processors.
549  template<class MatchPredicate1, class MatchPredicate2>
551  (
552  const MatchPredicate1& matchClass,
553  const MatchPredicate2& matchName,
554  const bool syncPar
555  ) const;
556 
557 
558  //- The sorted names of objects with headerClassName == Type::typeName
559  template<class Type>
560  wordList sortedNames() const;
561 
562  //- The sorted names of objects with headerClassName == Type::typeName
563  // With syncPar = true, sorts the names and triggers FatalError
564  // if the names are not consistent on all processors.
565  template<class Type>
566  wordList sortedNames(bool syncPar) const;
567 
568  //- The sorted names of objects with headerClassName == Type::typeName
569  //- that also have a matching object name.
570  // With syncPar = true, sorts the names and triggers FatalError
571  // if the names are not consistent on all processors.
572  template<class Type, class MatchPredicate>
573  wordList sortedNames(const MatchPredicate& matchName) const;
574 
575  //- The sorted names of objects with headerClassName == Type::typeName
576  //- that also have a matching object name.
577  // With syncPar = true, sorts the names and triggers FatalError
578  // if the names are not consistent on all processors.
579  template<class Type, class MatchPredicate>
581  (
582  const MatchPredicate& matchName,
583  const bool syncPar
584  ) const;
585 
586 
587  // Edit
588 
589  //- Filter to retain or prune given classes
590  // \return The number of items changed (removed)
591  template<class UnaryPredicate>
592  label filterClasses
593  (
594  const UnaryPredicate& pred,
595  const bool pruning = false
596  );
597 
598  //- Filter to retain or prune given object names
599  // \return The number of items changed (removed)
600  template<class UnaryPredicate>
601  label filterObjects
602  (
603  const UnaryPredicate& pred,
604  const bool pruning = false
605  );
606 
607  //- Remove objects with names ending with "_0" (restart fields)
608  // \return The number of items changed (removed)
609  label prune_0();
610 
611 
612  // Parallel
613 
614  //- The sorted names of all objects (synchronised across processors)
615  wordList allNames() const;
616 
617  //- The sorted names of all objects (synchronised across processors)
618  //- with headerClassName == Type::typeName
619  template<class Type>
620  wordList allNames() const;
621 
622  //- Verify that object names are synchronised across processors
623  // Triggers FatalError if the names are not consistent on all
624  // processors.
625  bool checkNames(const bool syncPar = true) const;
626 
627 
628  // Member Operators
629 
630  //- No copy assignment
631  void operator=(const IOobjectList&) = delete;
632 
633  //- Move assignment
634  void operator=(IOobjectList&& list);
635 
636 
637  // Housekeeping
638 
639  //- Deprecated(2018-11) Locate an object by name (c-string).
640  //- Disambiguated from multiple-lookup version by calling parameter.
641  // \deprecated(2018-11) use findObject() for non-ambiguous resolution
642  IOobject* lookup(const char* objName) const
643  {
644  return getObject(objName);
645  }
646 
647  //- Deprecated(2018-11) Locate an object by name (const word&).
648  //- Disambiguated from multiple-lookup version by calling parameter.
649  // \deprecated(2018-11) use findObject() for non-ambiguous resolution
650  IOobject* lookup(const word& objName) const
651  {
652  return getObject(objName);
653  }
654 };
655 
656 
657 // Ostream operator
658 Ostream& operator<<(Ostream& os, const IOobjectList& list);
659 
660 
661 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
662 
663 } // End namespace Foam
664 
665 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
666 
667 #ifdef NoRepository
668  #include "IOobjectListTemplates.C"
669 #endif
670 
671 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
672 
673 #endif
674 
675 // ************************************************************************* //
Foam::IOobject::NO_WRITE
Definition: IOobject.H:130
wordRes.H
Foam::IOobject
Defines the attributes of an object for which implicit objectRegistry management is supported,...
Definition: IOobject.H:104
Foam::word
A class for handling words, derived from Foam::string.
Definition: word.H:62
Foam::fileName
A class for handling file names.
Definition: fileName.H:69
Foam::IOobjectList::findObject
const IOobject * findObject(const word &objName) const
Return const pointer to the object found by name.
Definition: IOobjectList.C:270
Foam::IOobjectList::sortedNames
wordList sortedNames() const
The sorted names of the IOobjects.
Definition: IOobjectList.C:345
Foam::IOobjectList::append
label append(const IOobjectList &other)
Definition: IOobjectList.C:186
Foam::IOobjectList::count
label count() const
The number of objects with headerClassName == Type::typeName.
Foam::IOobjectList::names
wordList names() const
The names of the IOobjects.
Definition: IOobjectList.C:310
Foam::IOobjectList::filterObjects
label filterObjects(const UnaryPredicate &pred, const bool pruning=false)
Filter to retain or prune given object names.
Foam::objectRegistry
Registry of regIOobjects.
Definition: objectRegistry.H:60
Foam::operator<<
Ostream & operator<<(Ostream &, const boundaryPatch &p)
Write boundaryPatch as dictionary entries (without surrounding braces)
Definition: boundaryPatch.C:83
Foam::IOobject::writeOption
writeOption
Enumeration defining the write options.
Definition: IOobject.H:127
Foam::IOobjectList::classes
HashTable< wordHashSet > classes() const
A summary hash of classes used and their associated object names.
Definition: IOobjectList.C:297
Foam::IOobjectList::getObject
IOobject * getObject(const word &objName) const
Definition: IOobjectList.C:284
Foam::IOobjectList::remove
bool remove(const IOobject &io)
Remove IOobject from the list.
Definition: IOobjectList.C:236
Foam::IOobjectList::cfindObject
const IOobject * cfindObject(const word &objName) const
Return const pointer to the object found by name.
Definition: IOobjectList.C:245
Foam::IOobjectList::prune_0
label prune_0()
Remove objects with names ending with "_0" (restart fields)
Definition: IOobjectList.C:380
HashSet.H
Foam::IOobjectList::filterClasses
label filterClasses(const UnaryPredicate &pred, const bool pruning=false)
Filter to retain or prune given classes.
IOobject.H
Foam::IOobjectList::allNames
wordList allNames() const
The sorted names of all objects (synchronised across processors)
Definition: IOobjectList.C:391
Foam
Namespace for OpenFOAM.
Definition: atmBoundaryLayer.C:33
Foam::IOobjectList
List of IOobjects with searching and retrieving facilities.
Definition: IOobjectList.H:55
Foam::IOobjectList::IOobjectList
IOobjectList()
Construct null with default (128) table capacity.
Definition: IOobjectList.C:81
Foam::HashTable
A HashTable similar to std::unordered_map.
Definition: HashTable.H:105
Foam::autoPtr
Pointer management similar to std::unique_ptr, with some additional methods and type checking.
Definition: HashPtrTable.H:53
IOobjectListTemplates.C
Foam::IOobjectList::add
bool add(autoPtr< IOobject > &objectPtr)
Add IOobject to the list.
Definition: IOobjectList.C:164
Foam::IOobjectList::lookup
IOobjectList lookup(const MatchPredicate &matchName) const
The list of IOobjects that have a matching object name.
Foam::HashPtrTable
A HashTable of pointers to objects of type <T>.
Definition: HashPtrTable.H:54
Foam::IOobjectList::~IOobjectList
~IOobjectList()=default
Destructor.
Foam::IOobjectList::lookupClass
IOobjectList lookupClass() const
The list of IOobjects with headerClassName == Type::typeName.
Foam::List< word >
Foam::IOobjectList::operator=
void operator=(const IOobjectList &)=delete
No copy assignment.
HashPtrTable.H
Foam::IOobject::readOption
readOption
Enumeration defining the read options.
Definition: IOobject.H:118
Foam::Ostream
An Ostream is an abstract base class for all output systems (streams, files, token lists,...
Definition: Ostream.H:56
Foam::IOobject::MUST_READ
Definition: IOobject.H:120