zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'feature-ioobjectlist-registry' into 'develop'

Browse Source 
Feature ioobjectlist registry

See merge request Development/OpenFOAM-plus!218
This commit is contained in:
Andrew Heather
2018-11-12 11:39:01 +00:00
parent a89fedb2ec 9bc61e5f41
commit 9c993c8ebd
11 changed files with 1415 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
applications/test/IOobjectList/Test-IOobjectList.C
View File

@ -32,6 +32,8 @@ Description
#include "timeSelector.H"
#include "IOobjectList.H"
#include "hashedWordList.H"
#include "labelIOList.H"
#include "scalarIOList.H"
using namespace Foam;
@ -80,6 +82,67 @@ void reportDetail(const IOobjectList& objects)
}
template<class Type>
void filterTest(const IOobjectList& objs, const wordRe& re)
{
Info<< "Filter = " << re << nl;
const word& typeName = Type::typeName;
Info<< " <" << typeName <<">(" << re << ") : "
<< objs.count<Type>(re) << nl
<< " (" << typeName << "::typeName, " << re << ") : "
<< objs.count(typeName, re) << nl;
Info<< " <" << typeName << ">(" << re << ") : "
<< flatOutput(objs.sortedNames<Type>(re)) << nl
// << flatOutput(objs.names<Type>(re)) << nl
<< " (" << typeName << "::typeName, " << re << ") : "
<< flatOutput(objs.sortedNames(typeName, re)) << nl
//<< flatOutput(objs.names(typeName, re)) << nl
;
wordRe reClass("vol.*Field", wordRe::REGEX);
wordRe re2(re, wordRe::REGEX_ICASE);
Info<< "General" << nl
<< " <void>(" << re << ") : "
<< flatOutput(objs.sortedNames<void>(re)) << nl
<< " (" << reClass << ", " << re2 <<" ignore-case) : "
<< flatOutput(objs.sortedNames(reClass, re2)) << nl
;
Info<< nl;
}
void registryTests(const IOobjectList& objs)
{
Info<< nl << "IOobjectList " << flatOutput(objs.sortedNames()) << nl;
Info<< "count" << nl
<< " <void>() : " << objs.count<void>() << nl
<< " <labelList>() : " << objs.count<labelIOList>() << nl
<< " <scalarList>() : " << objs.count<scalarIOList>() << nl
<< nl;
Info<< " <volScalarField>() : "
<< objs.count<volScalarField>() << nl
<< " (volScalarField::typeName) : "
<< objs.count(volScalarField::typeName) << nl;
Info<< " <volVectorField>() : "
<< objs.count<volVectorField>() << nl
<< " (volVectorField::typeName) : "
<< objs.count(volVectorField::typeName) << nl;
Info<< nl << "Filter on names:" << nl;
filterTest<volScalarField>(objs, wordRe("[p-z].*", wordRe::DETECT));
Info<< nl;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
@ -165,6 +228,8 @@ int main(int argc, char *argv[])
Info<<"remove: " << flatOutput(subsetTypes) << nl;
Info<<"Pruned: " << classes << nl;
registryTests(objects);
// On last time
if (timeI == timeDirs.size()-1)
{

47
applications/test/objectRegistry/Test-objectRegistry.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\ / A nd | Copyright (C) 2016-2018 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -34,8 +34,8 @@ Description
#include "Time.H"
#include "polyMesh.H"
#include "IOstreams.H"
#include "FlatOutput.H"
#include "objectRegistry.H"
#include "hashedWordList.H"
using namespace Foam;
@ -45,22 +45,6 @@ using namespace Foam;
bool recursive = false;
template<class Type>
Foam::Ostream& printList(Foam::Ostream& os, const UList<Type>& list)
{
// list with out any linebreaks
os << '(';
forAll(list, i)
{
if (i) os << ' ';
os << list[i];
}
os << ')';
return os;
}
void printRegistry
(
Foam::Ostream& os,
@ -76,8 +60,8 @@ void printRegistry
Foam::label indent
)
{
wordList names = obr.sortedNames();
hashedWordList regs = obr.sortedNames<objectRegistry>();
wordList names(obr.sortedNames());
wordList regs(obr.sortedNames<objectRegistry>());
std::string prefix;
for (label i=indent; i; --i)
@ -88,23 +72,13 @@ void printRegistry
os << '#' << prefix.c_str() << obr.name()
<< " parent:" << obr.parent().name() << nl;
// all names
{
os << ' ' << prefix.c_str() << "objects: ";
printList(os, names) << nl;
}
os << ' ' << prefix.c_str() << "objects: " << flatOutput(names) << nl;
os << ' ' << prefix.c_str() << "registries: " << flatOutput(regs) << nl;
// sub-registry names
{
os << ' ' << prefix.c_str() << "registries: ";
printList(os, regs) << nl;
}
// Print, but skip expansion of sub-registries for now
forAll(names, i)
for (const word& name : names)
{
const word& name = names[i];
os << (regs.found(name) ? '-' : ' ')
<< prefix.c_str() << name << " => " << obr[name]->type() << nl;
}
@ -115,9 +89,8 @@ void printRegistry
os << '\n';
// Now descend into the sub-registries
forAll(regs, i)
for (const word& name : regs)
{
const word& name = regs[i];
const objectRegistry& next = obr.lookupObject<objectRegistry>
(
name,
@ -240,8 +213,8 @@ int main(int argc, char *argv[])
);
}
Info<< "after adding some entries, top-level now contains: ";
printList(Info, db.names()) << endl;
Info<< "after adding some entries, top-level now contains: "
<< flatOutput(db.names()) << endl;
Info<<"## Now attempt to add a few more entries ##" << nl;

3
applications/test/objectRegistry2/Make/files Normal file
View File

@ -0,0 +1,3 @@
Test-objectRegistry2.C
EXE = $(FOAM_USER_APPBIN)/Test-objectRegistry2

8
applications/test/objectRegistry2/Make/options Normal file
View File

@ -0,0 +1,8 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude
EXE_LIBS = \
-lfiniteVolume \
-lmeshTools \
-lgenericPatchFields

307
applications/test/objectRegistry2/Test-objectRegistry2.C Normal file
View File

@ -0,0 +1,307 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2018 OpenCFD Ltd.
\\/ 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/>.
Application
Test-objectRegistry2
Description
Print objectRegistry information, with some additional tests.
\*---------------------------------------------------------------------------*/
#include "argList.H"
#include "Time.H"
#include "fvCFD.H"
#include "fvMesh.H"
#include "volFields.H"
#include "IOobjectList.H"
#include "timeSelector.H"
#include "ReadFields.H"
#include "IOstreams.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type>
bool loadField(fvMesh& mesh, const word& fieldName)
{
typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
typedef GeometricField<Type, fvsPatchField, surfaceMesh> SurfaceFieldType;
if (mesh.objectRegistry::found(fieldName))
{
// Info<< fieldName << " already in database" << endl;
return false;
}
IOobject fieldHeader
(
fieldName,
mesh.time().timeName(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
);
if (fieldHeader.typeHeaderOk<VolFieldType>(true, true, false))
{
// Store field on mesh database
VolFieldType* ptr = new VolFieldType(fieldHeader, mesh);
mesh.objectRegistry::store(ptr);
return true;
}
else if (fieldHeader.typeHeaderOk<SurfaceFieldType>(true, true, false))
{
// Store field on mesh database
SurfaceFieldType* ptr = new SurfaceFieldType(fieldHeader, mesh);
mesh.objectRegistry::store(ptr);
return true;
}
return false;
}
bool loadField(fvMesh& mesh, const word& fieldName)
{
return
(
!mesh.objectRegistry::found(fieldName)
&&
(
loadField<scalar>(mesh, fieldName)
|| loadField<vector>(mesh, fieldName)
|| loadField<sphericalTensor>(mesh, fieldName)
|| loadField<symmTensor>(mesh, fieldName)
|| loadField<tensor>(mesh, fieldName)
)
);
}
void loadFields(fvMesh& mesh, const IOobjectList& objects)
{
for (const word& fieldName : objects.names())
{
loadField(mesh, fieldName);
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
void printRegistry
(
Foam::Ostream& os,
const Foam::objectRegistry& obr,
Foam::label indent = 4
);
void printRegistry
(
Foam::Ostream& os,
const Foam::objectRegistry& obr,
Foam::label indent
)
{
wordList names(obr.sortedNames());
wordList regs(obr.sortedNames<objectRegistry>());
std::string prefix;
for (label i=indent; i; --i)
{
prefix += ' ';
}
os << '#' << prefix.c_str() << obr.name()
<< " parent:" << obr.parent().name() << nl;
os << ' ' << prefix.c_str() << "objects: " << flatOutput(names) << nl;
os << ' ' << prefix.c_str() << "registries: " << flatOutput(regs) << nl;
// Print, but skip expansion of sub-registries for now
for (const word& name : names)
{
os << (regs.found(name) ? '-' : ' ')
<< prefix.c_str() << name << " => " << obr[name]->type() << nl;
}
for (label i=indent; i; --i)
{
os << '-'; // divider
}
os << '\n';
// Now descend into the sub-registries
for (const word& name : regs)
{
const objectRegistry& next = obr.lookupObject<objectRegistry>
(
name,
false // non-recursive
);
os << prefix.c_str()
<< "current:" << obr.name() << " next:"
<< next.name() << " next-parent:" << next.parent().name() << nl;
os << prefix.c_str() << name << " => " << obr[name]->type();
if ("dictionary" == obr[name]->type())
{
os << " (skip dictionary)" << nl;
}
else
{
os << nl;
printRegistry(os, next, indent + 4);
}
}
}
template<class Type>
void filterTest(const objectRegistry& obr, const wordRe& re)
{
Info<< nl << "Filter on names:" << nl;
Info<< "Filter = " << re << nl;
const word& typeName = Type::typeName;
Info<< " <" << typeName <<">(" << re << ") : "
<< obr.count<Type>(re) << nl
<< " (" << typeName << "::typeName, " << re << ") : "
<< obr.count(typeName, re) << nl;
Info<< " <" << typeName << ">(" << re << ") : "
<< flatOutput(obr.sortedNames<Type>(re)) << nl
// << flatOutput(obr.names<Type>(re)) << nl
<< " (" << typeName << "::typeName, " << re << ") : "
<< flatOutput(obr.sortedNames(typeName, re)) << nl
//<< flatOutput(obr.names(typeName, re)) << nl
;
wordRe reClass("vol.*Field", wordRe::REGEX);
wordRe re2(re, wordRe::REGEX_ICASE);
Info<< "General" << nl
<< " <void>(" << re << ") : "
<< flatOutput(obr.sortedNames<void>(re)) << nl
<< " (" << reClass << ", " << re2 <<" ignore-case) : "
<< flatOutput(obr.sortedNames(reClass, re2)) << nl
;
Info<< nl;
}
void registryTests(const objectRegistry& obr)
{
Info<< nl << "Registry: " << obr.name() << nl
<< " names: " << flatOutput(obr.sortedNames()) << nl;
Info<< "count" << nl
<< " <void>() : " << obr.count<void>() << nl
<< " <labelList>() : " << obr.count<labelList>() << nl
<< " <labelList>(strict) : " << obr.count<labelList>(true) << nl
<< " <scalarList>() : " << obr.count<scalarList>() << nl
<< " <scalarList>(strict) : " << obr.count<scalarList>(true) << nl;
Info<< " <volScalarField>() : "
<< obr.count<volScalarField>() << nl
<< " (volScalarField::typeName) : "
<< obr.count(volScalarField::typeName) << nl;
Info<< " <volVectorField>() : "
<< obr.count<volVectorField>() << nl
<< " (volVectorField::typeName) : "
<< obr.count(volVectorField::typeName) << nl;
Info<< nl << "Filter on names:" << nl;
filterTest<volScalarField>(obr, wordRe("[p-z].*", wordRe::DETECT));
Info<< nl;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
argList::noBanner();
argList::noParallel();
// argList::addOption
// (
// "filter",
// "wordRes",
// "filter keys with names or regexs"
// );
// timeSelector::addOptions();
timeSelector::addOptions(true, true);
#include "setRootCase.H"
// wordRes matcher;
// if (args.readListIfPresent<wordRe>("filter", matcher))
// {
// Info<<"limit names: " << matcher << nl;
// }
#include "createTime.H"
#include "createMesh.H"
instantList timeDirs = timeSelector::select0(runTime, args);
forAll(timeDirs, timeI)
{
runTime.setTime(timeDirs[timeI], timeI);
Info<< "Time: " << runTime.timeName() << endl;
// Read objects in time directory
IOobjectList objects(mesh, runTime.timeName());
// Read volFields
loadFields(mesh, objects);
printRegistry(Info, mesh);
registryTests(mesh);
Info<< nl;
}
Info<<"\nEnd\n" << endl;
return 0;
}
// ************************************************************************* //

82
src/OpenFOAM/db/IOobjectList/IOobjectList.C
View File

@ -33,7 +33,8 @@ License
bool Foam::IOobjectList::checkNames(wordList& masterNames, const bool syncPar)
{
// Sort for consistent order on all processors
// Sort for consistent order on all processors.
// Even do this for serial runs, for consistent behaviour
Foam::sort(masterNames);
if (syncPar && Pstream::parRun())
@ -273,6 +274,13 @@ Foam::HashTable<Foam::wordHashSet> Foam::IOobjectList::classes() const
}
Foam::label Foam::IOobjectList::count(const char* clsName) const
{
// No nullptr check - only called with string literals
return count(static_cast<word>(clsName));
}
Foam::wordList Foam::IOobjectList::names() const
{
return HashPtrTable<IOobject>::toc();
@ -288,37 +296,33 @@ Foam::wordList Foam::IOobjectList::names(const bool syncPar) const
}
Foam::wordList Foam::IOobjectList::names
(
const word& clsName
) const
Foam::wordList Foam::IOobjectList::names(const char* clsName) const
{
// sort/sync: false, false
return namesImpl(*this, clsName, predicates::always(), false, false);
// No nullptr check - only called with string literals
return names(static_cast<word>(clsName));
}
Foam::wordList Foam::IOobjectList::names
(
const word& clsName,
const char* clsName,
const bool syncPar
) const
{
// sort: false
return namesImpl(*this, clsName, predicates::always(), false, syncPar);
// No nullptr check - only called with string literals
return names(static_cast<word>(clsName), syncPar);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Foam::wordList Foam::IOobjectList::sortedNames() const
{
return HashPtrTable<IOobject>::sortedToc();
}
Foam::wordList Foam::IOobjectList::sortedNames
(
const bool syncPar
) const
Foam::wordList Foam::IOobjectList::sortedNames(const bool syncPar) const
{
wordList objNames(HashPtrTable<IOobject>::sortedToc());
@ -327,24 +331,56 @@ Foam::wordList Foam::IOobjectList::sortedNames
}
Foam::wordList Foam::IOobjectList::sortedNames
(
const word& clsName
) const
Foam::wordList Foam::IOobjectList::sortedNames(const char* clsName) const
{
// sort/sync: true, false
return namesImpl(*this, clsName, predicates::always(), true, false);
// No nullptr check - only called with string literals
return sortedNames(static_cast<word>(clsName));
}
Foam::wordList Foam::IOobjectList::sortedNames
(
const word& clsName,
const char* clsName,
const bool syncPar
) const
{
// sort: true
return namesImpl(*this, clsName, predicates::always(), true, syncPar);
// No nullptr check - only called with string literals
return names(static_cast<word>(clsName), syncPar);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Foam::label Foam::IOobjectList::prune_0()
{
return
HashPtrTable<IOobject>::filterKeys
(
[](const word& k){ return k.endsWith("_0"); },
true // prune
);
}
Foam::wordList Foam::IOobjectList::allNames() const
{
wordList objNames(HashPtrTable<IOobject>::toc());
syncNames(objNames);
return objNames;
}
bool Foam::IOobjectList::checkNames(const bool syncPar) const
{
if (syncPar && Pstream::parRun())
{
wordList objNames(HashPtrTable<IOobject>::toc());
return checkNames(objNames, syncPar);
}
return true;
}

263
src/OpenFOAM/db/IOobjectList/IOobjectList.H
View File

@ -76,6 +76,24 @@ class IOobjectList
const MatchPredicate& matchName
);
//- Templated implementation for count()
// The number of items with a matching class
template<class MatchPredicate1, class MatchPredicate2>
static label countImpl
(
const IOobjectList& list,
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
);
//- Templated implementation for count()
template<class Type, class MatchPredicate>
static label countTypeImpl
(
const IOobjectList& list,
const MatchPredicate& matchName
);
//- Templated implementation for names(), sortedNames()
template<class MatchPredicate1, class MatchPredicate2>
static wordList namesImpl
@ -83,8 +101,16 @@ class IOobjectList
const IOobjectList& list,
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName,
const bool doSort,
const bool syncPar
const bool doSort
);
//- Templated implementation for names(), sortedNames()
template<class Type, class MatchPredicate>
static wordList namesTypeImpl
(
const IOobjectList& list,
const MatchPredicate& matchName,
const bool doSort
);
//- Templated implementation for lookup()
@ -104,6 +130,14 @@ class IOobjectList
const MatchPredicate2& matchName
);
//- Templated implementation for lookupClass()
template<class Type, class MatchPredicate>
static IOobjectList lookupClassTypeImpl
(
const IOobjectList& list,
const MatchPredicate& matchName
);
public:
@ -181,17 +215,38 @@ public:
// Lookup multiple items
//- The list of all IOobjects that have a matching object name.
//- The list of IOobjects that have a matching object name.
template<class MatchPredicate>
IOobjectList lookup(const MatchPredicate& matchName) const;
//- The list of all IOobjects with the given headerClassName
//- The list of IOobjects with the given headerClassName
IOobjectList lookupClass(const char* clsName) const;
//- The list of all IOobjects with matching headerClassName
//- The list of IOobjects with matching headerClassName
template<class MatchPredicate>
IOobjectList lookupClass(const MatchPredicate& matchClass) const;
//- The list of IOobjects with matching headerClassName
//- that also have a matching object name.
template<class MatchPredicate1, class MatchPredicate2>
IOobjectList lookupClass
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
) const;
//- The list of IOobjects with headerClassName == Type::typeName
//
// \note If \a Type is \c void, no headerClassName check is used
// (always true).
template<class Type>
IOobjectList lookupClass() const;
//- The list of IOobjects with headerClassName == Type::typeName
//- that also have a matching object name.
template<class Type, class MatchPredicate>
IOobjectList lookupClass(const MatchPredicate& matchName) const;
// Summary of classes
@ -273,6 +328,41 @@ public:
HashTable<wordHashSet> classes(const MatchPredicate& matchName) const;
// Number of items
//- The number of objects of the given headerClassName
// \note uses the class type() method
label count(const char* clsName) const;
//- The number of objects of the given headerClassName
template<class MatchPredicate>
label count
(
const MatchPredicate& matchClass
) const;
//- The number of objects of the given headerClassName
//- that also have a matching object name.
template<class MatchPredicate1, class MatchPredicate2>
label count
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
) const;
//- The number of objects with headerClassName == Type::typeName
template<class Type>
label count() const;
//- The number of objects with headerClassName == Type::typeName
//- that also have a matching object name.
//
// \note If \a Type is \c void, no headerClassName check is used
// (always true).
template<class Type, class MatchPredicate>
label count(const MatchPredicate& matchName) const;
// Summary of names
//- The names of the IOobjects
@ -283,31 +373,74 @@ public:
// if the names are not consistent on all processors.
wordList names(const bool syncPar) const;
//- The names of IOobjects with the given class
wordList names(const word& clsName) const;
//- The names of IOobjects with the given headerClassName
wordList names(const char* clsName) const;
//- The names of the IOobjects with the given headerClassName
// With syncPar = true, sorts the names and triggers FatalError
// if the names are not consistent on all processors.
wordList names(const word& clsName, const bool syncPar) const;
wordList names(const char* clsName, const bool syncPar) const;
//- The names of IOobjects with the given headerClassName
//- that also have a matching object name.
template<class MatchPredicate>
wordList names(const MatchPredicate& matchClass) const;
//- The names of the IOobjects with the given headerClassName
// With syncPar = true, sorts the names and triggers FatalError
// if the names are not consistent on all processors.
template<class MatchPredicate>
wordList names
(
const word& clsName,
const MatchPredicate& matchName
const MatchPredicate& matchClass,
const bool syncPar
) const;
//- The names of IOobjects with the given headerClassName
//- that also have a matching object name.
template<class MatchPredicate1, class MatchPredicate2>
wordList names
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
) const;
//- The names of the IOobjects with the given headerClassName
//- that also have a matching object name.
// With syncPar = true, sorts the names and triggers FatalError
// if the names are not consistent on all processors.
template<class MatchPredicate>
template<class MatchPredicate1, class MatchPredicate2>
wordList names
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName,
const bool syncPar
) const;
//- The names of objects with headerClassName == Type::typeName
template<class Type>
wordList names() const;
//- The names of objects with headerClassName == Type::typeName
// With syncPar = true, sorts the names and triggers FatalError
// if the names are not consistent on all processors.
template<class Type>
wordList names(bool syncPar) const;
//- The names of objects with headerClassName == Type::typeName
//- that also have a matching object name.
// With syncPar = true, sorts the names and triggers FatalError
// if the names are not consistent on all processors.
template<class Type, class MatchPredicate>
wordList names(const MatchPredicate& matchName) const;
//- The names of objects with headerClassName == Type::typeName
//- that also have a matching object name.
// With syncPar = true, sorts the names and triggers FatalError
// if the names are not consistent on all processors.
template<class Type, class MatchPredicate>
wordList names
(
const word& clsName,
const MatchPredicate& matchName,
const bool syncPar
) const;
@ -318,41 +451,125 @@ public:
//- The sorted names of the IOobjects
wordList sortedNames() const;
//- The sorted names of the IOobjects
// With syncPar = true, a FatalError is
// triggered if the names are not consistent on all processors.
//- The sorted names of the IOobjects.
// With syncPar = true, sorts the names and triggers FatalError
// if the names are not consistent on all processors.
wordList sortedNames(const bool syncPar) const;
//- The sorted names of IOobjects with the given headerClassName
wordList sortedNames(const word& clsName) const;
wordList sortedNames(const char* clsName) const;
//- The sorted names of the IOobjects with the given headerClassName
// With syncPar = true, sorts the names and triggers FatalError
// if the names are not consistent on all processors.
wordList sortedNames(const word& clsName, const bool syncPar) const;
wordList sortedNames(const char* clsName, const bool syncPar) const;
//- The sorted names of IOobjects with the given headerClassName
template<class MatchPredicate>
wordList sortedNames(const MatchPredicate& matchClass) const;
//- The sorted names of the IOobjects with the given headerClassName
// With syncPar = true, sorts the names and triggers FatalError
// if the names are not consistent on all processors.
template<class MatchPredicate>
wordList sortedNames
(
const MatchPredicate& matchClass,
const bool syncPar
) const;
//- The sorted names of IOobjects with the given headerClassName
//- that also have a matching object name.
template<class MatchPredicate>
template<class MatchPredicate1, class MatchPredicate2>
wordList sortedNames
(
const word& clsName,
const MatchPredicate& matchName
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
) const;
//- The sorted names of the IOobjects with the given headerClassName
//- that also have a matching object name.
// With syncPar = true, sorts the names and triggers FatalError
// if the names are not consistent on all processors.
template<class MatchPredicate>
template<class MatchPredicate1, class MatchPredicate2>
wordList sortedNames
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName,
const bool syncPar
) const;
//- The sorted names of objects with headerClassName == Type::typeName
template<class Type>
wordList sortedNames() const;
//- The sorted names of objects with headerClassName == Type::typeName
// With syncPar = true, sorts the names and triggers FatalError
// if the names are not consistent on all processors.
template<class Type>
wordList sortedNames(bool syncPar) const;
//- The sorted names of objects with headerClassName == Type::typeName
//- that also have a matching object name.
// With syncPar = true, sorts the names and triggers FatalError
// if the names are not consistent on all processors.
template<class Type, class MatchPredicate>
wordList sortedNames(const MatchPredicate& matchName) const;
//- The sorted names of objects with headerClassName == Type::typeName
//- that also have a matching object name.
// With syncPar = true, sorts the names and triggers FatalError
// if the names are not consistent on all processors.
template<class Type, class MatchPredicate>
wordList sortedNames
(
const word& clsName,
const MatchPredicate& matchName,
const bool syncPar
) const;
// Edit
//- Filter to retain or prune given classes
// \return The number of items changed (removed)
template<class UnaryPredicate>
label filterClasses
(
const UnaryPredicate& pred,
const bool pruning = false
);
//- Filter to retain or prune given object names
// \return The number of items changed (removed)
template<class UnaryPredicate>
label filterObjects
(
const UnaryPredicate& pred,
const bool pruning = false
);
//- Remove objects with names ending with "_0" (restart fields)
// \return The number of items changed (removed)
label prune_0();
// Parallel
//- The sorted names of all objects (synchronised across processors)
wordList allNames() const;
//- The sorted names of all objects (synchronised across processors)
//- with headerClassName == Type::typeName
template<class Type>
wordList allNames() const;
//- Verify that object names are synchronised across processors
// Triggers FatalError if the names are not consistent on all
// processors.
bool checkNames(const bool syncPar = true) const;
// Member Operators
//- No copy assignment

410
src/OpenFOAM/db/IOobjectList/IOobjectListTemplates.C
View File

@ -55,6 +55,55 @@ Foam::HashTable<Foam::wordHashSet> Foam::IOobjectList::classesImpl
}
// Templated implementation for count()
template<class MatchPredicate1, class MatchPredicate2>
Foam::label Foam::IOobjectList::countImpl
(
const IOobjectList& list,
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
)
{
label count = 0;
forAllConstIters(list, iter)
{
const IOobject* io = iter.object();
if (matchClass(io->headerClassName()) && matchName(io->name()))
{
++count;
}
}
return count;
}
// Templated implementation for count()
template<class Type, class MatchPredicate>
Foam::label Foam::IOobjectList::countTypeImpl
(
const IOobjectList& list,
const MatchPredicate& matchName
)
{
label count = 0;
forAllConstIters(list, iter)
{
const IOobject* io = iter.object();
if (io->isHeaderClassName<Type>() && matchName(io->name()))
{
++count;
}
}
return count;
}
// Templated implementation for names(), sortedNames()
template<class MatchPredicate1, class MatchPredicate2>
Foam::wordList Foam::IOobjectList::namesImpl
@ -62,8 +111,7 @@ Foam::wordList Foam::IOobjectList::namesImpl
const IOobjectList& list,
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName,
const bool doSort,
const bool syncPar
const bool doSort
)
{
wordList objNames(list.size());
@ -81,14 +129,47 @@ Foam::wordList Foam::IOobjectList::namesImpl
}
}
objNames.setSize(count);
objNames.resize(count);
if (doSort)
{
Foam::sort(objNames);
}
checkNames(objNames, syncPar);
return objNames;
}
// Templated implementation for names(), sortedNames()
template<class Type, class MatchPredicate>
Foam::wordList Foam::IOobjectList::namesTypeImpl
(
const IOobjectList& list,
const MatchPredicate& matchName,
const bool doSort
)
{
wordList objNames(list.size());
label count = 0;
forAllConstIters(list, iter)
{
const word& key = iter.key();
const IOobject* io = iter.object();
if (io->isHeaderClassName<Type>() && matchName(key))
{
objNames[count] = key;
++count;
}
}
objNames.resize(count);
if (doSort)
{
Foam::sort(objNames);
}
return objNames;
}
@ -155,6 +236,36 @@ Foam::IOobjectList Foam::IOobjectList::lookupClassImpl
}
// Templated implementation for lookupClass()
template<class Type, class MatchPredicate>
Foam::IOobjectList Foam::IOobjectList::lookupClassTypeImpl
(
const IOobjectList& list,
const MatchPredicate& matchName
)
{
IOobjectList results(list.size());
forAllConstIters(list, iter)
{
const word& key = iter.key();
const IOobject* io = iter.object();
if (io->isHeaderClassName<Type>() && matchName(key))
{
if (IOobject::debug)
{
InfoInFunction << "Found " << key << endl;
}
results.set(key, new IOobject(*io));
}
}
return results;
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class MatchPredicate>
@ -177,6 +288,34 @@ Foam::IOobjectList Foam::IOobjectList::lookupClass
}
template<class MatchPredicate1, class MatchPredicate2>
Foam::IOobjectList Foam::IOobjectList::lookupClass
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
) const
{
return lookupClassImpl(*this, matchClass, matchName);
}
template<class Type>
Foam::IOobjectList Foam::IOobjectList::lookupClass() const
{
return lookupClassTypeImpl<Type>(*this, predicates::always());
}
template<class Type, class MatchPredicate>
Foam::IOobjectList Foam::IOobjectList::lookupClass
(
const MatchPredicate& matchName
) const
{
return lookupClassImpl<Type>(*this, matchName);
}
template<class MatchPredicate>
Foam::HashTable<Foam::wordHashSet>
Foam::IOobjectList::classes
@ -189,52 +328,283 @@ Foam::IOobjectList::classes
template<class MatchPredicate>
Foam::wordList Foam::IOobjectList::names
Foam::label Foam::IOobjectList::count
(
const MatchPredicate& matchClass
) const
{
return countImpl(*this, matchClass, predicates::always());
}
template<class MatchPredicate1, class MatchPredicate2>
Foam::label Foam::IOobjectList::count
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
) const
{
return countImpl(*this, matchClass, matchName);
}
template<class Type>
Foam::label Foam::IOobjectList::count() const
{
return countTypeImpl<Type>(*this, predicates::always());
}
template<class Type, class MatchPredicate>
Foam::label Foam::IOobjectList::count
(
const word& clsName,
const MatchPredicate& matchName
) const
{
// sort/sync: false, false
return namesImpl(*this, clsName, matchName, false, false);
return countTypeImpl<Type>(*this, matchName);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class MatchPredicate>
Foam::wordList Foam::IOobjectList::names
(
const MatchPredicate& matchClass
) const
{
return namesImpl(*this, matchClass, predicates::always(), false);
}
template<class MatchPredicate>
Foam::wordList Foam::IOobjectList::names
(
const word& clsName,
const MatchPredicate& matchName,
const MatchPredicate& matchClass,
const bool syncPar
) const
{
// sort: false
return namesImpl(*this, clsName, matchName, false, syncPar);
wordList objNames
(
namesImpl(*this, matchClass, predicates::always(), false)
);
checkNames(objNames, syncPar);
return objNames;
}
template<class MatchPredicate>
Foam::wordList Foam::IOobjectList::sortedNames
template<class MatchPredicate1, class MatchPredicate2>
Foam::wordList Foam::IOobjectList::names
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
) const
{
return namesImpl(*this, matchClass, matchName, false);
}
template<class MatchPredicate1, class MatchPredicate2>
Foam::wordList Foam::IOobjectList::names
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName,
const bool syncPar
) const
{
wordList objNames(namesImpl(*this, matchClass, matchName, false));
checkNames(objNames, syncPar);
return objNames;
}
template<class Type>
Foam::wordList Foam::IOobjectList::names() const
{
return namesTypeImpl<Type>(*this, predicates::always(), false);
}
template<class Type>
Foam::wordList Foam::IOobjectList::names(const bool syncPar) const
{
wordList objNames(namesTypeImpl<Type>(*this, predicates::always(), false));
checkNames(objNames, syncPar);
return objNames;
}
template<class Type, class MatchPredicate>
Foam::wordList Foam::IOobjectList::names
(
const word& clsName,
const MatchPredicate& matchName
) const
{
// sort/sync: true, false
return namesImpl(*this, clsName, matchName, true, false);
return namesTypeImpl<Type>(*this, matchName, false);
}
template<class Type, class MatchPredicate>
Foam::wordList Foam::IOobjectList::names
(
const MatchPredicate& matchName,
const bool syncPar
) const
{
wordList objNames(namesTypeImpl<Type>(*this, matchName, false));
checkNames(objNames, syncPar);
return objNames;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class MatchPredicate>
Foam::wordList Foam::IOobjectList::sortedNames
(
const MatchPredicate& matchClass
) const
{
return namesImpl(*this, matchClass, predicates::always(), true);
}
template<class MatchPredicate>
Foam::wordList Foam::IOobjectList::sortedNames
(
const word& clsName,
const MatchPredicate& matchClass,
const bool syncPar
) const
{
wordList objNames
(
namesImpl(*this, matchClass, predicates::always(), true)
);
checkNames(objNames, syncPar);
return objNames;
}
template<class MatchPredicate1, class MatchPredicate2>
Foam::wordList Foam::IOobjectList::sortedNames
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
) const
{
return namesImpl(*this, matchClass, matchName, true);
}
template<class MatchPredicate1, class MatchPredicate2>
Foam::wordList Foam::IOobjectList::sortedNames
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName,
const bool syncPar
) const
{
wordList objNames(namesImpl(*this, matchClass, matchName, true));
checkNames(objNames, syncPar);
return objNames;
}
template<class Type>
Foam::wordList Foam::IOobjectList::sortedNames() const
{
return namesTypeImpl<Type>(*this, predicates::always(), true);
}
template<class Type>
Foam::wordList Foam::IOobjectList::sortedNames(const bool syncPar) const
{
wordList objNames(namesTypeImpl<Type>(*this, predicates::always(), true));
checkNames(objNames, syncPar);
return objNames;
}
template<class Type, class MatchPredicate>
Foam::wordList Foam::IOobjectList::sortedNames
(
const MatchPredicate& matchName
) const
{
return namesTypeImpl<Type>(*this, matchName, true);
}
template<class Type, class MatchPredicate>
Foam::wordList Foam::IOobjectList::sortedNames
(
const MatchPredicate& matchName,
const bool syncPar
) const
{
// sort: true
return namesImpl(*this, clsName, matchName, true, syncPar);
return namesTypeImpl<Type>(*this, matchName, true, syncPar);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class UnaryPredicate>
Foam::label Foam::IOobjectList::filterClasses
(
const UnaryPredicate& pred,
const bool pruning
)
{
// return HashPtrTable<IOobject>::filterValues
// (
// [&](const IOobject* io){ return pred(io->headerClassName()); },
// pruning
// );
label changed = 0;
for (iterator iter = begin(); iter != end(); ++iter)
{
// Matches? either prune (pruning) or keep (!pruning)
if
(
(pred(iter.object()->headerClassName()) ? pruning : !pruning)
&& erase(iter)
)
{
++changed;
}
}
return changed;
}
template<class UnaryPredicate>
Foam::label Foam::IOobjectList::filterObjects
(
const UnaryPredicate& pred,
const bool pruning
)
{
return HashPtrTable<IOobject>::filterKeys(pred, pruning);
}
template<class Type>
Foam::wordList Foam::IOobjectList::allNames() const
{
wordList objNames(namesTypeImpl<Type>(*this, predicates::always(), false));
syncNames(objNames);
return objNames;
}

46
src/OpenFOAM/db/objectRegistry/objectRegistry.C
View File

@ -111,24 +111,10 @@ Foam::HashTable<Foam::wordHashSet> Foam::objectRegistry::classes() const
}
Foam::HashTable<Foam::wordHashSet>
Foam::objectRegistry::classes(const wordRe& matchName) const
Foam::label Foam::objectRegistry::count(const char* clsName) const
{
return classesImpl(*this, matchName);
}
Foam::HashTable<Foam::wordHashSet>
Foam::objectRegistry::classes(const wordRes& matchName) const
{
return classesImpl(*this, matchName);
}
Foam::HashTable<Foam::wordHashSet>
Foam::objectRegistry::classes(const wordHashSet& matchName) const
{
return classesImpl(*this, matchName);
// No nullptr check - only called with string literals
return count(static_cast<word>(clsName));
}
@ -144,31 +130,17 @@ Foam::wordList Foam::objectRegistry::sortedNames() const
}
Foam::wordList Foam::objectRegistry::names(const word& clsName) const
Foam::wordList Foam::objectRegistry::names(const char* clsName) const
{
wordList objNames(size());
label count=0;
for (const_iterator iter = cbegin(); iter != cend(); ++iter)
{
if (iter()->type() == clsName)
{
objNames[count++] = iter.key();
}
}
objNames.setSize(count);
return objNames;
// No nullptr check - only called with string literals
return names(static_cast<word>(clsName));
}
Foam::wordList Foam::objectRegistry::sortedNames(const word& clsName) const
Foam::wordList Foam::objectRegistry::sortedNames(const char* clsName) const
{
wordList objNames = names(clsName);
Foam::sort(objNames);
return objNames;
// No nullptr check - only called with string literals
return sortedNames(static_cast<word>(clsName));
}

164
src/OpenFOAM/db/objectRegistry/objectRegistry.H
View File

@ -81,6 +81,25 @@ class objectRegistry
// Used to terminate searching within the ancestors
bool parentNotTime() const;
//- Templated implementation for count()
// The number of items with a matching class
template<class MatchPredicate1, class MatchPredicate2>
static label countImpl
(
const objectRegistry& list,
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
);
//- Templated implementation for count()
// The number of items with a matching class
template<class Type, class MatchPredicate>
static label countTypeImpl
(
const objectRegistry& list,
const MatchPredicate& matchName
);
//- Templated implementation for classes()
template<class MatchPredicate>
static HashTable<wordHashSet> classesImpl
@ -89,6 +108,16 @@ class objectRegistry
const MatchPredicate& matchName
);
//- Templated implementation for names(), sortedNames()
template<class MatchPredicate1, class MatchPredicate2>
static wordList namesImpl
(
const objectRegistry& list,
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName,
const bool doSort
);
//- Templated implementation for names(), sortedNames()
template<class Type, class MatchPredicate>
static wordList namesTypeImpl
@ -157,26 +186,74 @@ public:
// Behaviour and usage as per IOobjectList::classes
HashTable<wordHashSet> classes() const;
//- A summary hash of classes used and their associated object names
//- restricted to objects with names that satisfy the input matcher
HashTable<wordHashSet> classes(const wordRe& matchName) const;
//- A summary hash of classes used and their associated object names,
//- restricted to objects that have a matching object name.
template<class MatchPredicate>
HashTable<wordHashSet> classes(const MatchPredicate& matchName) const;
//- A summary hash of classes used and their associated object names
//- restricted to objects with names that satisfy the input matcher
HashTable<wordHashSet> classes(const wordRes& matchName) const;
//- A summary hash of classes used and their associated object names
//- restricted to objects with names that satisfy the input matcher
HashTable<wordHashSet> classes(const wordHashSet& matchName) const;
// Number of items
//- The number of objects of the given class name
// \note uses the class type() method
label count(const char* clsName) const;
//- The number of objects of the given class name
// \note uses the class type() method
template<class MatchPredicate>
label count(const MatchPredicate& matchClass) const;
//- The number of objects of the given class name
// \note uses the class type() method
template<class MatchPredicate1, class MatchPredicate2>
label count
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
) const;
//- The names of objects with a class satisfying \c isA\<Type\>
//
// \param strict use \c isType\<Type\> instead of \c isA\<Type\>
//
// \note The values of \c count\<Type\>() and \c count(Type::typeName)
// may be inconsistent, since they use different mechanisms for
// testing the class type.
// \note If \a Type is \c void, no isA check is used (always true).
template<class Type>
label count(const bool strict = false) const;
//- The names of objects with a class satisfying \c isA\<Type\>
//- that also have a matching object name.
//
// \note If \a Type is \c void, no isA check is used (always true).
template<class Type, class MatchPredicate>
label count(const MatchPredicate& matchName) const;
// Summary of names
//- The names of the objects
//- The names of all objects
wordList names() const;
//- The names of objects with the given class
wordList names(const word& clsName) const;
//- The names of objects with the given class name.
// \note uses the class type() method
wordList names(const char* clsName) const;
//- The names of objects with a matching class name
// \note uses the class type() method
template<class MatchPredicate>
wordList names(const MatchPredicate& matchClass) const;
//- The names of objects with a matching class name
//- that also have a matching object name.
// \note uses the class type() method
template<class MatchPredicate1, class MatchPredicate2>
wordList names
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
) const;
//- The names of objects with a class satisfying \c isA\<Type\>.
//
@ -185,62 +262,49 @@ public:
wordList names() const;
//- The names of objects with a class satisfying \c isA\<Type\>
//- that also have a name satisfying the input matcher
//- that also have a matching object name.
//
// \note If \a Type is \c void, no isA check is used (always true).
template<class Type>
wordList names(const wordRe& matchName) const;
//- The names of objects with a class satisfying \c isA\<Type\>
//- that also have a name satisfying the input matcher
//
// \note If \a Type is \c void, no isA check is used (always true).
template<class Type>
wordList names(const wordRes& matchName) const;
//- The names of objects with a class satisfying \c isA\<Type\>
//- that also have a name satisfying the input matcher
//
// \note If \a Type is \c void, no isA check is used (always true).
template<class Type>
wordList names(const wordHashSet& matchName) const;
template<class Type, class MatchPredicate>
wordList names(const MatchPredicate& matchName) const;
// Summary of names (sorted)
//- The sorted names of the objects
//- The sorted names of all objects
wordList sortedNames() const;
//- The sorted names of objects with the given class
wordList sortedNames(const word& clsName) const;
//- The sorted names of objects with the given class name.
// \note uses the class type() method
wordList sortedNames(const char* clsName) const;
//- The sorted names objects with a matching class name
// \note uses the class type() method
template<class MatchPredicate>
wordList sortedNames(const MatchPredicate& matchClass) const;
//- The sorted names of objects with a matching class name
//- that also have a matching object name.
// \note uses the class type() method
template<class MatchPredicate1, class MatchPredicate2>
wordList sortedNames
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
) const;
//- The sorted names of objects with a class satisfying \c isA\<Type\>
//- that also have a name satisfying the input matcher
//
// \note If \a Type is \c void, no isA check is used (always true).
template<class Type>
wordList sortedNames() const;
//- The sorted names of objects with a class satisfying \c isA\<Type\>
//- that also have a name satisfying the input matcher
//- that also have a matching object name.
//
// \note If \a Type is \c void, no isA check is used (always true).
template<class Type>
wordList sortedNames(const wordRe& matchName) const;
//- The sorted names of objects with a class satisfying \c isA\<Type\>
//- that also have a name satisfying the input matcher
//
// \note If \a Type is \c void, no isA check is used (always true).
template<class Type>
wordList sortedNames(const wordRes& matchName) const;
//- The sorted names of objects with a class satisfying \c isA\<Type\>
//- that also have a name satisfying the input matcher
//
// \note If \a Type is \c void, no isA check is used (always true).
template<class Type>
wordList sortedNames(const wordHashSet& matchName) const;
template<class Type, class MatchPredicate>
wordList sortedNames(const MatchPredicate& matchName) const;
// Lookup

249
src/OpenFOAM/db/objectRegistry/objectRegistryTemplates.C
View File

@ -42,10 +42,12 @@ Foam::HashTable<Foam::wordHashSet> Foam::objectRegistry::classesImpl
// Summary (key,val) = (class-name, object-names)
forAllConstIters(list, iter)
{
if (matchName(iter.key()))
const regIOobject* obj = iter.object();
if (matchName(obj->name()))
{
// Create entry (if needed) and insert
summary(iter.object()->type()).insert(iter.key());
summary(iter.object()->type()).insert(obj->name());
}
}
@ -53,6 +55,94 @@ Foam::HashTable<Foam::wordHashSet> Foam::objectRegistry::classesImpl
}
// Templated implementation for count()
template<class MatchPredicate1, class MatchPredicate2>
Foam::label Foam::objectRegistry::countImpl
(
const objectRegistry& list,
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
)
{
label count = 0;
forAllConstIters(list, iter)
{
const regIOobject* obj = iter.object();
if (matchClass(obj->type()) && matchName(obj->name()))
{
++count;
}
}
return count;
}
// Templated implementation for count()
template<class Type, class MatchPredicate>
Foam::label Foam::objectRegistry::countTypeImpl
(
const objectRegistry& list,
const MatchPredicate& matchName
)
{
label count = 0;
forAllConstIters(list, iter)
{
const regIOobject* obj = iter.object();
if
(
(std::is_void<Type>::value || isA<Type>(*obj))
&& matchName(obj->name())
)
{
++count;
}
}
return count;
}
// Templated implementation for names(), sortedNames()
template<class MatchPredicate1, class MatchPredicate2>
Foam::wordList Foam::objectRegistry::namesImpl
(
const objectRegistry& list,
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName,
const bool doSort
)
{
wordList objNames(list.size());
label count=0;
forAllConstIters(list, iter)
{
const regIOobject* obj = iter.object();
if (matchClass(obj->type()) && matchName(obj->name()))
{
objNames[count] = obj->name();
++count;
}
}
objNames.resize(count);
if (doSort)
{
Foam::sort(objNames);
}
return objNames;
}
// Templated implementation for names(), sortedNames()
template<class Type, class MatchPredicate>
Foam::wordList Foam::objectRegistry::namesTypeImpl
@ -75,7 +165,7 @@ Foam::wordList Foam::objectRegistry::namesTypeImpl
&& matchName(obj->name())
)
{
objNames[count] = iter()->name();
objNames[count] = obj->name();
++count;
}
}
@ -93,6 +183,95 @@ Foam::wordList Foam::objectRegistry::namesTypeImpl
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class MatchPredicate>
Foam::HashTable<Foam::wordHashSet>
Foam::objectRegistry::classes
(
const MatchPredicate& matchName
) const
{
return classesImpl(*this, matchName);
}
template<class MatchPredicate>
Foam::label Foam::objectRegistry::count
(
const MatchPredicate& matchClass
) const
{
return countImpl(*this, matchClass, predicates::always());
}
template<class MatchPredicate1, class MatchPredicate2>
Foam::label Foam::objectRegistry::count
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
) const
{
return countImpl(*this, matchClass, matchName);
}
template<class Type, class MatchPredicate>
Foam::label Foam::objectRegistry::count
(
const MatchPredicate& matchName
) const
{
return countTypeImpl<Type>(*this, matchName);
}
template<class Type>
Foam::label Foam::objectRegistry::count
(
const bool strict
) const
{
label nObjects = 0;
forAllConstIters(*this, iter)
{
const regIOobject* obj = iter.object();
if
(
std::is_void<Type>::value
|| (strict ? isType<Type>(*obj) : bool(isA<Type>(*obj)))
)
{
++nObjects;
}
}
return nObjects;
}
template<class MatchPredicate>
Foam::wordList Foam::objectRegistry::names
(
const MatchPredicate& matchClass
) const
{
return namesImpl(*this, matchClass, predicates::always(), false);
}
template<class MatchPredicate1, class MatchPredicate2>
Foam::wordList Foam::objectRegistry::names
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
) const
{
return namesImpl(*this, matchClass, matchName, false);
}
template<class Type>
Foam::wordList Foam::objectRegistry::names() const
{
@ -100,24 +279,34 @@ Foam::wordList Foam::objectRegistry::names() const
}
template<class Type>
Foam::wordList Foam::objectRegistry::names(const wordRe& matchName) const
template<class Type, class MatchPredicate>
Foam::wordList Foam::objectRegistry::names
(
const MatchPredicate& matchName
) const
{
return namesTypeImpl<Type>(*this, matchName, false);
}
template<class Type>
Foam::wordList Foam::objectRegistry::names(const wordRes& matchName) const
template<class MatchPredicate>
Foam::wordList Foam::objectRegistry::sortedNames
(
const MatchPredicate& matchClass
) const
{
return namesTypeImpl<Type>(*this, matchName, false);
return namesImpl(*this, matchClass, predicates::always(), true);
}
template<class Type>
Foam::wordList Foam::objectRegistry::names(const wordHashSet& matchName) const
template<class MatchPredicate1, class MatchPredicate2>
Foam::wordList Foam::objectRegistry::sortedNames
(
const MatchPredicate1& matchClass,
const MatchPredicate2& matchName
) const
{
return namesTypeImpl<Type>(*this, matchName, false);
return namesImpl(*this, matchClass, matchName, true);
}
@ -128,24 +317,10 @@ Foam::wordList Foam::objectRegistry::sortedNames() const
}
template<class Type>
Foam::wordList Foam::objectRegistry::sortedNames(const wordRe& matchName) const
{
return namesTypeImpl<Type>(*this, matchName, true);
}
template<class Type>
Foam::wordList Foam::objectRegistry::sortedNames(const wordRes& matchName) const
{
return namesTypeImpl<Type>(*this, matchName, true);
}
template<class Type>
template<class Type, class MatchPredicate>
Foam::wordList Foam::objectRegistry::sortedNames
(
const wordHashSet& matchName
const MatchPredicate& matchName
) const
{
return namesTypeImpl<Type>(*this, matchName, true);
@ -162,13 +337,11 @@ Foam::HashTable<const Type*> Foam::objectRegistry::lookupClass
forAllConstIters(*this, iter)
{
if (strict ? isType<Type>(*iter()) : bool(isA<Type>(*iter())))
const regIOobject* obj = iter.object();
if (strict ? isType<Type>(*obj) : bool(isA<Type>(*obj)))
{
objectsOfClass.insert
(
iter()->name(),
dynamic_cast<const Type*>(iter())
);
objectsOfClass.insert(obj->name(), dynamic_cast<const Type*>(obj));
}
}
@ -186,13 +359,11 @@ Foam::HashTable<Type*> Foam::objectRegistry::lookupClass
forAllIters(*this, iter)
{
if (strict ? isType<Type>(*iter()) : bool(isA<Type>(*iter())))
regIOobject* obj = iter.object();
if (strict ? isType<Type>(*obj) : bool(isA<Type>(*obj)))
{
objectsOfClass.insert
(
iter()->name(),
dynamic_cast<Type*>(iter())
);
objectsOfClass.insert(obj->name(), dynamic_cast<Type*>(obj));
}
}