functionObjectList.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | Copyright (C) 2011-2016 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 \*---------------------------------------------------------------------------*/
25 
26 #include "functionObjectList.H"
27 #include "Time.H"
28 #include "mapPolyMesh.H"
29 #include "argList.H"
31 #include "IFstream.H"
32 #include "dictionaryEntry.H"
33 #include "stringOps.H"
34 #include "Tuple2.H"
35 #include "etcFiles.H"
36 
37 /* * * * * * * * * * * * * * * Static Member Data * * * * * * * * * * * * * */
38 
40 (
41  "caseDicts/postProcessing"
42 );
43 
44 
45 // * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
46 
47 Foam::functionObject* Foam::functionObjectList::remove
48 (
49  const word& key,
50  label& oldIndex
51 )
52 {
53  functionObject* ptr = 0;
54 
55  // Find index of existing functionObject
56  HashTable<label>::iterator fnd = indices_.find(key);
57 
58  if (fnd != indices_.end())
59  {
60  oldIndex = fnd();
61 
62  // Retrieve the pointer and remove it from the old list
63  ptr = this->set(oldIndex, 0).ptr();
64  indices_.erase(fnd);
65  }
66  else
67  {
68  oldIndex = -1;
69  }
70 
71  return ptr;
72 }
73 
74 
75 void Foam::functionObjectList::listDir
76 (
77  const fileName& dir,
78  HashSet<word>& foMap
79 )
80 {
81  // Search specified directory for functionObject configuration files
82  {
83  fileNameList foFiles(readDir(dir));
84  forAll(foFiles, f)
85  {
86  if (foFiles[f].ext().empty())
87  {
88  foMap.insert(foFiles[f]);
89  }
90  }
91  }
92 
93  // Recurse into sub-directories
94  {
96  forAll(foDirs, fd)
97  {
98  listDir(dir/foDirs[fd], foMap);
99  }
100  }
101 }
102 
103 
105 {
106  HashSet<word> foMap;
107 
109 
110  forAll(etcDirs, ed)
111  {
112  listDir(etcDirs[ed], foMap);
113  }
114 
115  Info<< nl
116  << "Available configured functionObjects:"
117  << foMap.sortedToc()
118  << nl;
119 }
120 
121 
123 {
124  // First check if there is a functionObject dictionary file in the
125  // case system directory
126  fileName dictFile = stringOps::expand("$FOAM_CASE")/"system"/funcName;
127 
128  if (isFile(dictFile))
129  {
130  return dictFile;
131  }
132  else
133  {
135 
136  forAll(etcDirs, i)
137  {
138  dictFile = search(funcName, etcDirs[i]);
139  if (!dictFile.empty())
140  {
141  return dictFile;
142  }
143  }
144  }
145 
146  return fileName::null;
147 }
148 
149 
151 (
152  const string& funcNameArgs,
153  dictionary& functionsDict,
154  HashSet<word>& requiredFields,
155  const word& region
156 )
157 {
158  // Parse the optional functionObject arguments:
159  // 'Q(U)' -> funcName = Q; args = (U); field = U
160  //
161  // Supports named arguments:
162  // 'patchAverage(patch=inlet, p)' -> funcName = patchAverage;
163  // args = (patch=inlet, p); field = p
164 
165  word funcName(funcNameArgs);
166 
167  int argLevel = 0;
168  wordList args;
169 
170  List<Tuple2<word, string>> namedArgs;
171  bool namedArg = false;
172  word argName;
173 
175  word::size_type i = 0;
176 
177  for
178  (
179  word::const_iterator iter = funcNameArgs.begin();
180  iter != funcNameArgs.end();
181  ++iter
182  )
183  {
184  char c = *iter;
185 
186  if (c == '(')
187  {
188  if (argLevel == 0)
189  {
190  funcName = funcNameArgs(start, i - start);
191  start = i+1;
192  }
193  ++argLevel;
194  }
195  else if (c == ',' || c == ')')
196  {
197  if (argLevel == 1)
198  {
199  if (namedArg)
200  {
201  namedArgs.append
202  (
204  (
205  argName,
206  funcNameArgs(start, i - start)
207  )
208  );
209  namedArg = false;
210  }
211  else
212  {
213  args.append
214  (
215  string::validate<word>(funcNameArgs(start, i - start))
216  );
217  }
218  start = i+1;
219  }
220 
221  if (c == ')')
222  {
223  if (argLevel == 1)
224  {
225  break;
226  }
227  --argLevel;
228  }
229  }
230  else if (c == '=')
231  {
232  argName = string::validate<word>(funcNameArgs(start, i - start));
233  start = i+1;
234  namedArg = true;
235  }
236 
237  ++i;
238  }
239 
240  // Search for the functionObject dictionary
241  fileName path = findDict(funcName);
242 
243  if (path == fileName::null)
244  {
246  << "Cannot find functionObject file " << funcName << endl;
247  return false;
248  }
249 
250  // Read the functionObject dictionary
251  IFstream fileStream(path);
252  dictionary funcsDict(fileStream);
253  dictionary* funcDictPtr = &funcsDict;
254 
255  if (funcsDict.found(funcName) && funcsDict.isDict(funcName))
256  {
257  funcDictPtr = &funcsDict.subDict(funcName);
258  }
259 
260  dictionary& funcDict = *funcDictPtr;
261 
262  // Insert the 'field' and/or 'fields' entry corresponding to the optional
263  // arguments or read the 'field' or 'fields' entry and add the required
264  // fields to requiredFields
265  if (args.size() == 1)
266  {
267  funcDict.set("field", args[0]);
268  funcDict.set("fields", args);
269  requiredFields.insert(args[0]);
270  }
271  else if (args.size() > 1)
272  {
273  funcDict.set("fields", args);
274  requiredFields.insert(args);
275  }
276  else if (funcDict.found("field"))
277  {
278  requiredFields.insert(word(funcDict.lookup("field")));
279  }
280  else if (funcDict.found("fields"))
281  {
282  requiredFields.insert(wordList(funcDict.lookup("fields")));
283  }
284 
285  // Insert named arguments
286  forAll(namedArgs, i)
287  {
288  IStringStream entryStream
289  (
290  namedArgs[i].first() + ' ' + namedArgs[i].second() + ';'
291  );
292  funcDict.set(entry::New(entryStream).ptr());
293  }
294 
295  // Insert the region name if specified
296  if (region != word::null)
297  {
298  funcDict.set("region", region);
299  }
300 
301  // Merge this functionObject dictionary into functionsDict
302  dictionary funcArgsDict;
303  funcArgsDict.add(string::validate<word>(funcNameArgs), funcDict);
304  functionsDict.merge(funcArgsDict);
305 
306  return true;
307 }
308 
309 
310 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
311 
312 Foam::functionObjectList::functionObjectList
313 (
314  const Time& t,
315  const bool execution
316 )
317 :
319  digests_(),
320  indices_(),
321  time_(t),
322  parentDict_(t.controlDict()),
323  execution_(execution),
324  updated_(false)
325 {}
326 
327 
328 Foam::functionObjectList::functionObjectList
329 (
330  const Time& t,
331  const dictionary& parentDict,
332  const bool execution
333 )
334 :
336  digests_(),
337  indices_(),
338  time_(t),
339  parentDict_(parentDict),
340  execution_(execution),
341  updated_(false)
342 {}
343 
344 
346 (
347  const argList& args,
348  const Time& runTime,
349  dictionary& controlDict,
350  HashSet<word>& requiredFields
351 )
352 {
353  autoPtr<functionObjectList> functionsPtr;
354 
355  controlDict.add
356  (
357  dictionaryEntry("functions", controlDict, dictionary::null)
358  );
359 
360  dictionary& functionsDict = controlDict.subDict("functions");
361 
362  word region = word::null;
363 
364  // Set the region name if specified
365  if (args.optionFound("region"))
366  {
367  region = args["region"];
368  }
369 
370  if
371  (
372  args.optionFound("dict")
373  || args.optionFound("func")
374  || args.optionFound("funcs")
375  )
376  {
377  if (args.optionFound("dict"))
378  {
379  controlDict.merge
380  (
382  (
383  IOobject
384  (
385  args["dict"],
386  runTime,
388  )
389  )
390  );
391  }
392 
393  if (args.optionFound("func"))
394  {
396  (
397  args["func"],
398  functionsDict,
399  requiredFields,
400  region
401  );
402  }
403 
404  if (args.optionFound("funcs"))
405  {
406  wordList funcs(args.optionLookup("funcs")());
407 
408  forAll(funcs, i)
409  {
411  (
412  funcs[i],
413  functionsDict,
414  requiredFields,
415  region
416  );
417  }
418  }
419 
420  functionsPtr.reset(new functionObjectList(runTime, controlDict));
421  }
422  else
423  {
424  functionsPtr.reset(new functionObjectList(runTime));
425  }
426 
427  functionsPtr->start();
428 
429  return functionsPtr;
430 }
431 
432 
433 // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
434 
436 {}
437 
438 
439 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
440 
442 {
444  digests_.clear();
445  indices_.clear();
446  updated_ = false;
447 }
448 
449 
451 {
452  forAll(*this, objectI)
453  {
454  if (operator[](objectI).name() == name)
455  {
456  return objectI;
457  }
458  }
459 
460  return -1;
461 }
462 
463 
465 {
466  execution_ = true;
467 }
468 
469 
471 {
472  // For safety, also force a read() when execution is turned back on
473  updated_ = execution_ = false;
474 }
475 
476 
478 {
479  return execution_;
480 }
481 
482 
484 {
485  return read();
486 }
487 
488 
490 {
491  bool ok = true;
492 
493  if (execution_)
494  {
495  if (!updated_)
496  {
497  read();
498  }
499 
500  forAll(*this, objectI)
501  {
502  ok = operator[](objectI).execute() && ok;
503  ok = operator[](objectI).write() && ok;
504  }
505  }
506 
507  return ok;
508 }
509 
510 
512 {
513  bool ok = true;
514 
515  if (execution_)
516  {
517  if (!updated_)
518  {
519  read();
520  }
521 
522  forAll(*this, objectI)
523  {
524  ok = operator[](objectI).end() && ok;
525  }
526  }
527 
528  return ok;
529 }
530 
531 
533 {
534  bool ok = true;
535 
536  if (execution_)
537  {
538  if (!updated_)
539  {
540  read();
541  }
542 
543  forAll(*this, objectI)
544  {
545  ok = operator[](objectI).adjustTimeStep() && ok;
546  }
547  }
548 
549  return ok;
550 }
551 
552 
554 {
555  bool ok = true;
556  updated_ = execution_;
557 
558  // Avoid reading/initializing if execution is off
559  if (!execution_)
560  {
561  return true;
562  }
563 
564  // Update existing and add new functionObjects
565  const entry* entryPtr = parentDict_.lookupEntryPtr
566  (
567  "functions",
568  false,
569  false
570  );
571 
572  if (entryPtr)
573  {
574  PtrList<functionObject> newPtrs;
575  List<SHA1Digest> newDigs;
576  HashTable<label> newIndices;
577 
578  label nFunc = 0;
579 
580  if (!entryPtr->isDict())
581  {
582  FatalIOErrorInFunction(parentDict_)
583  << "'functions' entry is not a dictionary"
584  << exit(FatalIOError);
585  }
586 
587  const dictionary& functionsDict = entryPtr->dict();
588 
589  const_cast<Time&>(time_).libs().open
590  (
591  functionsDict,
592  "libs",
593  functionObject::dictionaryConstructorTablePtr_
594  );
595 
596  newPtrs.setSize(functionsDict.size());
597  newDigs.setSize(functionsDict.size());
598 
599  forAllConstIter(dictionary, functionsDict, iter)
600  {
601  const word& key = iter().keyword();
602 
603  if (!iter().isDict())
604  {
605  if (key != "libs")
606  {
607  IOWarningInFunction(parentDict_)
608  << "Entry " << key << " is not a dictionary" << endl;
609  }
610 
611  continue;
612  }
613 
614  const dictionary& dict = iter().dict();
615  bool enabled = dict.lookupOrDefault("enabled", true);
616 
617  newDigs[nFunc] = dict.digest();
618 
619  label oldIndex;
620  functionObject* objPtr = remove(key, oldIndex);
621 
622  if (objPtr)
623  {
624  if (enabled)
625  {
626  // Dictionary changed for an existing functionObject
627  if (newDigs[nFunc] != digests_[oldIndex])
628  {
629  ok = objPtr->read(dict) && ok;
630  }
631  }
632  else
633  {
634  // Delete the disabled functionObject
635  delete objPtr;
636  objPtr = NULL;
637  continue;
638  }
639  }
640  else if (enabled)
641  {
643 
646  try
647  {
648  if
649  (
650  dict.found("writeControl")
651  || dict.found("outputControl")
652  )
653  {
654  foPtr.set
655  (
656  new functionObjects::timeControl(key, time_, dict)
657  );
658  }
659  else
660  {
661  foPtr = functionObject::New(key, time_, dict);
662  }
663  }
664  catch (Foam::IOerror& ioErr)
665  {
666  Info<< ioErr << nl << endl;
667  ::exit(1);
668  }
669  catch (Foam::error& err)
670  {
672  << "Caught FatalError " << err << nl << endl;
673  }
676 
677  if (foPtr.valid())
678  {
679  objPtr = foPtr.ptr();
680  }
681  else
682  {
683  ok = false;
684  }
685  }
686 
687  // Insert active functionObjects into the list
688  if (objPtr)
689  {
690  newPtrs.set(nFunc, objPtr);
691  newIndices.insert(key, nFunc);
692  nFunc++;
693  }
694  }
695 
696  newPtrs.setSize(nFunc);
697  newDigs.setSize(nFunc);
698 
699  // Updating the PtrList of functionObjects deletes any
700  // existing unused functionObjects
702  digests_.transfer(newDigs);
703  indices_.transfer(newIndices);
704  }
705  else
706  {
708  digests_.clear();
709  indices_.clear();
710  }
711 
712  return ok;
713 }
714 
715 
717 {
718  if (execution_)
719  {
720  forAll(*this, objectI)
721  {
722  operator[](objectI).updateMesh(mpm);
723  }
724  }
725 }
726 
727 
729 {
730  if (execution_)
731  {
732  forAll(*this, objectI)
733  {
734  operator[](objectI).movePoints(mesh);
735  }
736  }
737 }
738 
739 
740 // ************************************************************************* //
bool read()
Read and set the function objects if their data have changed.
A HashTable with keys but without contents.
Definition: HashSet.H:59
dictionary dict
#define forAll(list, i)
Loop across all elements in list.
Definition: UList.H:428
static bool readFunctionObject(const string &funcNameArgs0, dictionary &functionsDict, HashSet< word > &requiredFields, const word &region=word::null)
Read the specified functionObject configuration dictionary parsing.
intWM_LABEL_SIZE_t label
A label is an int32_t or int64_t as specified by the pre-processor macro WM_LABEL_SIZE.
Definition: label.H:59
A class for handling file names.
Definition: fileName.H:69
errorManipArg< error, int > exit(error &err, const int errNo=1)
Definition: errorManip.H:124
label findObjectID(const word &name) const
Find the ID of a given function object by name.
static iteratorEnd end()
iteratorEnd set to beyond the end of any HashTable
Definition: HashTable.H:106
void off()
Switch the function objects off.
error FatalError
A list of keyword definitions, which are a keyword followed by any number of values (e...
Definition: dictionary.H:137
A 2-tuple for storing two objects of different types.
Definition: Tuple2.H:47
A 1D array of objects of type <T>, where the size of the vector is known and used for subscript bound...
Definition: HashTable.H:59
static void list()
Print a list of functionObject configuration files in.
void size(const label)
Override size to be inconsistent with allocated storage.
Definition: ListI.H:76
static const dictionary null
Null dictionary.
Definition: dictionary.H:193
const dictionary & subDict(const word &) const
Find and return a sub-dictionary.
Definition: dictionary.C:633
static const fileName null
An empty fileName.
Definition: fileName.H:97
bool isDict(const word &) const
Check if entry is a sub-dictionary.
Definition: dictionary.C:602
static bool New(dictionary &parentDict, Istream &)
Construct from Istream and insert into dictionary.
Definition: entryIO.C:91
bool isFile(const fileName &, const bool checkGzip=true)
Does the name exist as a FILE in the file system?
Definition: POSIX.C:492
Ostream & endl(Ostream &os)
Add newline and flush stream.
Definition: Ostream.H:253
const entry * lookupEntryPtr(const word &, bool recursive, bool patternMatch) const
Find and return an entry data stream pointer if present.
Definition: dictionary.C:345
virtual const dictionary & dict() const =0
Return dictionary if this entry is a dictionary.
void on()
Switch the function objects on.
void transfer(HashTable< T, Key, Hash > &)
Transfer the contents of the argument table into this table.
Definition: HashTable.C:509
bool adjustTimeStep()
Called at the end of Time::adjustDeltaT() if adjustTime is true.
T * ptr()
Return object pointer for reuse.
Definition: autoPtrI.H:90
Abstract base-class for Time/database function objects.
label size() const
Return number of elements in list.
Definition: DLListBaseI.H:77
bool insert(const Key &key)
Insert a new entry.
Definition: HashSet.H:116
A keyword and a list of tokens is a &#39;dictionaryEntry&#39;.
Class to control time during OpenFOAM simulations that is also the top-level objectRegistry.
Definition: Time.H:68
bool start()
Called at the start of the time-loop.
Class containing mesh-to-mesh mapping information after a change in polyMesh topology.
Definition: mapPolyMesh.H:158
bool add(entry *, bool mergeEntry=false)
Add a new entry.
Definition: dictionary.C:737
bool erase(const iterator &)
Erase a hashedEntry specified by given iterator.
Definition: HashTable.C:367
IOdictionary is derived from dictionary and IOobject to give the dictionary automatic IO functionalit...
Definition: IOdictionary.H:53
Class to handle errors and exceptions in a simple, consistent stream-based manner.
Definition: error.H:66
bool insert(const Key &, const T &newElmt)
Insert a new hashedEntry.
Definition: HashTableI.H:80
iterator find(const Key &)
Find and return an iterator set at the hashedEntry.
Definition: HashTable.C:138
bool execute()
Called at each ++ or += of the time-loop.
void reset(T *=0)
If object pointer already set, delete object and set to given.
Definition: autoPtrI.H:114
dynamicFvMesh & mesh
void throwExceptions()
Definition: error.H:122
bool optionFound(const word &opt) const
Return true if the named option is found.
Definition: argListI.H:108
A class for handling words, derived from string.
Definition: word.H:59
Functions to search &#39;etc&#39; directories for configuration files etc.
Extract command arguments and options from the supplied argc and argv parameters. ...
Definition: argList.H:102
void clear()
Clear all entries from table.
Definition: HashTable.C:464
void append(const T &)
Append an element at the end of the list.
Definition: ListI.H:97
static fileName findDict(const word &funcName)
Search for functionObject dictionary file in.
string expand(const string &, const HashTable< string, word, string::hash > &mapping, const char sigil= '$')
Expand occurences of variables according to the mapping.
Definition: stringOps.C:75
bool set(const label) const
Is element set.
Definition: PtrListI.H:65
static const word null
An empty word.
Definition: word.H:77
bool found(const word &, bool recursive=false, bool patternMatch=true) const
Search dictionary for given keyword.
Definition: dictionary.C:306
List of function objects with start(), execute() and end() functions that is called for each object...
graph_traits< Graph >::vertices_size_type size_type
Definition: SloanRenumber.C:73
forAllConstIter(PtrDictionary< phaseModel >, mixture.phases(), phase)
Definition: pEqn.H:29
Report an I/O error.
Definition: error.H:196
bool valid() const
Return true if the autoPtr valid (ie, the pointer is set).
Definition: autoPtrI.H:83
void setSize(const label)
Reset size of PtrList. If extending the PtrList, new entries are.
Definition: PtrList.C:131
virtual bool read(const dictionary &)
Read and set the function object if its data have changed.
static const char nl
Definition: Ostream.H:262
fileName path(UMean.rootPath()/UMean.caseName()/"graphs"/UMean.instance())
void set(T *)
Set pointer to that given.
Definition: autoPtrI.H:99
Input from file stream.
Definition: IFstream.H:81
labelList f(nPoints)
word name(const complex &)
Return a string representation of a complex.
Definition: complex.C:47
void clear()
Clear the list of function objects.
List< word > wordList
A List of words.
Definition: fileName.H:54
const T & operator[](const label) const
Return element const reference.
Definition: UPtrListI.H:103
void setSize(const label)
Reset size of List.
Definition: List.C:295
bool empty() const
Return true if the UPtrList is empty (ie, size() is zero)
Definition: UPtrListI.H:36
#define WarningInFunction
Report a warning using Foam::Warning.
#define FatalIOErrorInFunction(ios)
Report an error message using Foam::FatalIOError.
Definition: error.H:331
bool status() const
Return the execution status (on/off) of the function objects.
Input from memory buffer stream.
Definition: IStringStream.H:49
List< Key > sortedToc() const
Return the table of contents as a sorted list.
SHA1Digest digest() const
Return the SHA1 digest of the dictionary contents.
Definition: dictionary.C:272
const dimensionedScalar c
Speed of light in a vacuum.
void transfer(PtrList< T > &)
Transfer the contents of the argument PtrList into this PtrList.
Definition: PtrList.C:189
static autoPtr< functionObject > New(const word &name, const Time &, const dictionary &)
Select from dictionary, based on its "type" entry.
IStringStream optionLookup(const word &opt) const
Return an IStringStream from the named option.
Definition: argListI.H:114
void set(entry *)
Assign a new entry, overwrite any existing entry.
Definition: dictionary.C:864
void clear()
Clear the PtrList, i.e. set size to zero deleting all the.
Definition: PtrList.C:174
messageStream Info
bool merge(const dictionary &)
Merge entries from the given dictionary.
Definition: dictionary.C:1013
fileName search(const word &file, const fileName &directory)
Recursively search the given directory for the file.
Definition: fileName.C:401
#define IOWarningInFunction(ios)
Report an IO warning using Foam::Warning.
An auto-pointer similar to the STL auto_ptr but with automatic casting to a reference to the type and...
Definition: PtrList.H:53
Mesh consisting of general polyhedral cells.
Definition: polyMesh.H:74
const dictionary & controlDict() const
Definition: Time.H:274
void updateMesh(const mapPolyMesh &mpm)
Update for changes of mesh.
static autoPtr< functionObjectList > New(const argList &args, const Time &runTime, dictionary &controlDict, HashSet< word > &requiredFields)
Construct and return a functionObjectList for an application.
friend class iterator
Declare friendship with the iterator.
Definition: HashTable.H:189
Foam::argList args(argc, argv)
void movePoints(const polyMesh &mesh)
Update for changes of mesh.
List< fileName > fileNameList
A List of fileNames.
Definition: fileNameList.H:50
IOobject defines the attributes of an object for which implicit objectRegistry management is supporte...
Definition: IOobject.H:91
T lookupOrDefault(const word &, const T &, bool recursive=false, bool patternMatch=true) const
Find and return a T,.
fileNameList readDir(const fileName &, const fileName::Type=fileName::FILE, const bool filtergz=true)
Read a directory and return the entries as a string list.
Definition: POSIX.C:527
static fileName functionObjectDictPath
Default relative path to the directory structure.
bool end()
Called when Time::run() determines that the time-loop exits.
virtual bool isDict() const
Return true if this entry is a dictionary.
Definition: entry.H:153
A keyword and a list of tokens is an &#39;entry&#39;.
Definition: entry.H:65
void dontThrowExceptions()
Definition: error.H:127
ITstream & lookup(const word &, bool recursive=false, bool patternMatch=true) const
Find and return an entry data stream.
Definition: dictionary.C:451
IOerror FatalIOError
fileNameList findEtcDirs(const fileName &local=fileName::null)
Search for directories from user/group/shipped directories.
Definition: etcFiles.C:32
T & first()
Return reference to the first element of the list.
Definition: UPtrListI.H:43