95cd8ee75c
- additional dummy template parameter to assist with supporting
derived classes. Currently just used for string types, but can be
extended.
- provide hash specialization for various integer types.
Removes the need for any forwarding.
- change default hasher for HashSet/HashTable from 'string::hash'
to `Hash<Key>`. This avoids questionable hashing calls and/or
avoids compiler resolution problems.
For example,
HashSet<label>::hasher and labelHashSet::hasher now both properly
map to Hash<label> whereas previously HashSet<label> would have
persistently mapped to string::hash, which was incorrect.
- standardize internal hashing functors.
Functor name is 'hasher', as per STL set/map and the OpenFOAM
HashSet/HashTable definitions.
Older code had a local templated name, which added unnecessary
clutter and the template parameter was always defaulted.
For example,
Old: `FixedList<label, 3>::Hash<>()`
New: `FixedList<label, 3>::hasher()`
Unchanged: `labelHashSet::hasher()`
Existing `Hash<>` functor namings are still supported,
but deprecated.
- define hasher and Hash specialization for bitSet and PackedList
- add symmetric hasher for 'face'.
Starts with lowest vertex value and walks in the direction
of the next lowest value. This ensures that the hash code is
independent of face orientation and face rotation.
NB:
- some of keys for multiphase handling (eg, phasePairKey)
still use yet another function naming: `hash` and `symmHash`.
This will be targeted for alignment in the future.
445 lines
13 KiB
C
445 lines
13 KiB
C
/*---------------------------------------------------------------------------*\
|
|
========= |
|
|
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
|
\\ / O peration |
|
|
\\ / A nd | www.openfoam.com
|
|
\\/ M anipulation |
|
|
-------------------------------------------------------------------------------
|
|
Copyright (C) 2011-2013 OpenFOAM Foundation
|
|
Copyright (C) 2016-2020 OpenCFD Ltd.
|
|
-------------------------------------------------------------------------------
|
|
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/>.
|
|
|
|
Description
|
|
Test some string functionality
|
|
|
|
\*---------------------------------------------------------------------------*/
|
|
|
|
#include "string.H"
|
|
#include "stringOps.H"
|
|
#include "dictionary.H"
|
|
#include "IOstreams.H"
|
|
#include "OSspecific.H"
|
|
|
|
#include "int.H"
|
|
#include "uint.H"
|
|
#include "scalar.H"
|
|
#include "Switch.H"
|
|
#include "fileName.H"
|
|
#include "stringList.H"
|
|
#include "stringOps.H"
|
|
|
|
using namespace Foam;
|
|
|
|
void testCommentStripping(const std::string& s)
|
|
{
|
|
Info<< "input" << nl
|
|
<< "========" << nl
|
|
<< s << nl
|
|
<< "========" << nl;
|
|
|
|
Info<< "output" << nl
|
|
<< "========" << nl
|
|
<< stringOps::removeComments(s) << nl
|
|
<< "========" << nl << nl;
|
|
}
|
|
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
// Main program:
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
string test
|
|
(
|
|
" $HOME kjhkjhkjh \" \\$HOME/tyetyery $; ${FOAM_RUN} \n $; hkjh;"
|
|
" $(DONOTSUBST) some other <${USER}> with '${__UNKNOWN:-some default}'"
|
|
" value "
|
|
" or with '${HOME:+Home was set}' via :+ alternative"
|
|
" or with '${__UNKNOWN:+unknown}' empty "
|
|
);
|
|
|
|
setEnv("FOAM_CASE", cwd(), true);
|
|
|
|
dictionary dict;
|
|
dict.add("HOME", "myHome");
|
|
|
|
dictionary subDict;
|
|
subDict.add("value1", "test1");
|
|
subDict.add("value2", "test2");
|
|
dict.add("FOAM_RUN", subDict);
|
|
|
|
if (false)
|
|
{
|
|
typedef std::string inputType;
|
|
typedef string outputType;
|
|
|
|
inputType in1("move-construct-from");
|
|
|
|
Info<<"move construct from " << in1.length() << nl;
|
|
|
|
outputType out1(std::move(in1));
|
|
|
|
Info<<"after move construct "
|
|
<< out1.size() << ", " << in1.size() << nl;
|
|
|
|
in1 = "move-assign-from";
|
|
out1 = "some-text-rubbish";
|
|
out1.resize(10);
|
|
|
|
Info<<"move assign from " << in1.length() << nl;
|
|
|
|
out1 = std::move(in1);
|
|
|
|
Info<<"after move assign "
|
|
<< out1.size() << ", " << in1.size() << nl;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
// basic expansions
|
|
{
|
|
for
|
|
(
|
|
const auto& cstr
|
|
:
|
|
{
|
|
"~OpenFOAM/controlDict", "<etc>/controlDict",
|
|
"<etc:ugo>/controlDict",
|
|
"<etc:u>/controlDict",
|
|
"<etc:ug>/controlDict",
|
|
"<etc:go>/controlDict",
|
|
"<etc:o>/controlDict",
|
|
"<etc:JUNK>/controlDict", // rubbish input
|
|
"<etc:>/controlDict", // rubbish input
|
|
"$FOAM_CASE/xyz", "<case>/xyz",
|
|
"$FOAM_CASE/constant/xyz", "<constant>/xyz",
|
|
"$FOAM_CASE/system/xyz", "<system>/xyz",
|
|
|
|
// corner cases
|
|
"~OpenFOAM", "<etc>",
|
|
"~OpenFOAM/", "<etc>/",
|
|
"$FOAM_CASE", "<case>",
|
|
"$FOAM_CASE/constant", "<constant>",
|
|
"$FOAM_CASE/system", "<system>",
|
|
|
|
"$FOAM_CASE/", "<case>/",
|
|
"$FOAM_CASE/constant/", "<constant>/",
|
|
"$FOAM_CASE/system/", "<system>/",
|
|
}
|
|
)
|
|
{
|
|
string input(cstr);
|
|
string output(stringOps::expand(input));
|
|
|
|
Info<< "input: " << input << nl
|
|
<< "expand: " << output << nl
|
|
<< "split: " << stringOps::split(output, "/") << nl << nl;
|
|
}
|
|
}
|
|
|
|
|
|
// Test Foam::name with formatting string
|
|
{
|
|
word formatted = word::printf("formatted=<%X>", 0xdeadbeef);
|
|
Info<<"formatted: " << formatted << nl;
|
|
}
|
|
|
|
Info<<"formatted: "
|
|
<< word::printf("formatted not checked for validity=<%X>", 0xdeadbeef)
|
|
<< nl
|
|
<< endl;
|
|
|
|
|
|
Info<< "string:" << test << nl << "hash:"
|
|
<< unsigned(string::hasher()(test)) << endl;
|
|
|
|
Info<<"trimLeft: " << stringOps::trimLeft(test) << endl;
|
|
Info<<"trimRight: " << stringOps::trimRight(test) << endl;
|
|
Info<<"trim: " << stringOps::trim(test) << endl;
|
|
|
|
// With replace, replaceAll
|
|
{
|
|
string test2(test);
|
|
Info<<"replaceAny: (\"abcj\", '?')" << nl
|
|
<< test2.replaceAny("abcj", '?') << endl;
|
|
Info<<"replaceAll: (\"k\", \"?\")" << nl
|
|
<< test2.replaceAll("k", "?") << endl;
|
|
Info<<"replaceAll: (\"h\", null) - ie, remove them" << nl
|
|
<< test2.replaceAll("h", "") << endl;
|
|
Info<<"replaceAny: (\"it${}?\", null) - ie, remove them" << nl
|
|
<< test2.replaceAny("it${}?", '\0') << endl;
|
|
}
|
|
|
|
if (false)
|
|
{
|
|
Info<<"test move construct - string size:" << test.size() << nl;
|
|
string test2(std::move(test));
|
|
|
|
Info<<"input size:" << test.size() << nl;
|
|
Info<<"moved size:" << test2.size() << nl;
|
|
|
|
Info<<"test move assign - string sizes:"
|
|
<< test.size() << "/" << test2.size() << nl;
|
|
|
|
test = std::move(test2);
|
|
|
|
Info<<"input size:" << test.size() << nl;
|
|
Info<<"moved size:" << test2.size() << nl;
|
|
}
|
|
|
|
if (false)
|
|
{
|
|
std::string str("some text");
|
|
|
|
Info<<"test move construct to string:" << str.size() << nl;
|
|
|
|
Foam::string test2(std::move(str));
|
|
|
|
Info<<"input/moved sizes:" << str.size() << "/" << test2.size() << nl;
|
|
|
|
str = std::move(test2);
|
|
|
|
Info<<"test move assign - sizes:"
|
|
<< str.size() << "/" << test2.size() << nl;
|
|
}
|
|
|
|
if (false)
|
|
{
|
|
Foam::string str("thisIsAWord");
|
|
|
|
Info<<"test move construct to word:" << str.size() << nl;
|
|
|
|
word test2(std::move(str));
|
|
|
|
Info<<"input/moved sizes:" << str.size() << "/" << test2.size() << nl;
|
|
|
|
str = std::move(test2);
|
|
|
|
Info<<"test move assign - sizes:"
|
|
<< str.size() << "/" << test2.size() << nl;
|
|
|
|
// move back
|
|
test2.swap(str);
|
|
|
|
Info<<"test move assign - sizes:"
|
|
<< str.size() << "/" << test2.size() << nl;
|
|
|
|
string str2(std::move(test2));
|
|
Info<<"input/moved sizes:" << test2.size() << "/" << str2.size() << nl;
|
|
|
|
}
|
|
|
|
{
|
|
fileName test1("libFooBar.so");
|
|
|
|
Info<< nl;
|
|
Info<< "trim filename: " << test1 << nl;
|
|
|
|
test1.removeStart("lib");
|
|
Info<<"without leading 'lib': " << test1 << nl;
|
|
}
|
|
|
|
Info<< nl;
|
|
Info<<"camel-case => " << (word("camel") & "case") << nl;
|
|
for (const auto& s : { " text with \"spaces'", "08/15 value" })
|
|
{
|
|
// Character sequence
|
|
|
|
Info<<"validated 5 chars from \" => "
|
|
<< word::validate(s, s+5, true) << nl;
|
|
|
|
Info<<"validated (via string convert) \"" << s << "\" => "
|
|
<< word::validate(s, true) << nl;
|
|
}
|
|
Info<< nl;
|
|
|
|
// test sub-strings via iterators
|
|
string::const_iterator iter = test.end();
|
|
string::const_iterator iter2 = test.end();
|
|
string::size_type fnd = test.find('\\');
|
|
|
|
if (fnd != string::npos)
|
|
{
|
|
iter = test.begin() + fnd;
|
|
iter2 = iter + 6;
|
|
}
|
|
|
|
Info<< "sub-string via iterators : >";
|
|
while (iter != iter2)
|
|
{
|
|
Info<< *iter;
|
|
++iter;
|
|
}
|
|
Info<< "<\n";
|
|
|
|
Info<< string(test).replace("kj", "zzz") << endl;
|
|
Info<< string(test).replace("kj", "") << endl;
|
|
Info<< string(test).replaceAll("kj", "zzz") << endl;
|
|
Info<< string(test).replaceAll("kj", "z") << endl;
|
|
|
|
Info<< "expanded: " << string(test).expand() << endl;
|
|
|
|
Info<<"dictionary-based substitution: " << dict << endl;
|
|
Info<< "expand dict: " << stringOps::expand(test, dict) << endl;
|
|
|
|
string test2("~OpenFOAM/controlDict");
|
|
Info<< test2 << " => " << test2.expand() << endl;
|
|
|
|
// replace controlDict with "newName"
|
|
{
|
|
string::size_type i = test2.rfind('/');
|
|
|
|
if (i == string::npos)
|
|
{
|
|
test2 = "newName";
|
|
}
|
|
else
|
|
{
|
|
// this uses the std::string::replace
|
|
test2.replace(i+1, string::npos, "newName");
|
|
}
|
|
Info<< "after replace: " << test2 << endl;
|
|
|
|
// do another replace
|
|
// this uses the Foam::string::replace
|
|
test2.replace("OpenFOAM", "openfoam");
|
|
|
|
Info<< "after replace: " << test2 << endl;
|
|
}
|
|
|
|
cout<< "\nEnter some string to test:\n";
|
|
|
|
string s;
|
|
Sin.getLine(s);
|
|
|
|
string s2(s.expand());
|
|
|
|
cout<< "output string with " << s2.length() << " characters\n";
|
|
cout<< "ostream<< >" << s2 << "<\n";
|
|
Info<< "Ostream<< >" << s2 << "<\n";
|
|
Info<< "hash:" << hex << string::hasher()(s2) << dec << endl;
|
|
|
|
cout<< "\ntest Foam::name()\n";
|
|
|
|
Info<< "hash: = " << word::printf("0x%012X", string::hasher()(s2)) << endl;
|
|
|
|
// Test formatting on int
|
|
{
|
|
label val = 25;
|
|
Info<< "int " << val << " nameOp='"
|
|
<< nameOp<label>()(val) << "', name='"
|
|
<< Foam::name(val) << "' or "
|
|
<< word::printf("formatted '%08d'", val) << "\n";
|
|
}
|
|
|
|
// Test formatting on scalar
|
|
{
|
|
scalar val = 3.1415926535897931;
|
|
Info<< "scalar " << val << " nameOp='"
|
|
<< nameOp<scalar>()(val) << "', name='"
|
|
<< Foam::name(val) << "' or "
|
|
<< word::printf("formatted '%.9f'", val) << "\n";
|
|
}
|
|
|
|
// Test formatting on uint
|
|
{
|
|
uint64_t val = 25000000ul;
|
|
Info<< "uint64 " << val << " nameOp='"
|
|
<< nameOp<uint64_t>()(val) << "', name='"
|
|
<< Foam::name(val) << "' or "
|
|
<< word::printf("formatted '%08d'", val) << "\n";
|
|
}
|
|
|
|
// test starts_with, ends_with methods
|
|
{
|
|
string empty; //;
|
|
string input1 = "shorter input";
|
|
string input2 = "longer input text";
|
|
|
|
stringList checks{"match", "long", "", "short", "text", "s", "l", "t"};
|
|
|
|
Info<< nl;
|
|
Info<< "check starts_with:" << nl
|
|
<< "~~~~~~~~~~~~~~~~~" << nl;
|
|
|
|
Info<<"input: " << empty << nl;
|
|
for (const string& test : checks)
|
|
{
|
|
Info<< " starts_with(" << test << ") = "
|
|
<< Switch(empty.starts_with(test)) << nl;
|
|
}
|
|
Info<<"input: " << input1 << nl;
|
|
for (const string& test : checks)
|
|
{
|
|
Info<< " starts_with(" << test << ") = "
|
|
<< Switch(input1.starts_with(test)) << nl;
|
|
}
|
|
Info<<"input: " << input2 << nl;
|
|
for (const string& test : checks)
|
|
{
|
|
Info<< " starts_with(" << test << ") = "
|
|
<< Switch(input2.starts_with(test)) << nl;
|
|
}
|
|
|
|
|
|
Info<< nl;
|
|
Info<< "check ends_with:" << nl
|
|
<< "~~~~~~~~~~~~~~~~~" << nl;
|
|
|
|
Info<<"input: " << empty << nl;
|
|
for (const string& test : checks)
|
|
{
|
|
Info<< " ends_with(" << test << ") = "
|
|
<< Switch(empty.ends_with(test)) << nl;
|
|
}
|
|
Info<<"input: " << input1 << nl;
|
|
for (const string& test : checks)
|
|
{
|
|
Info<< " ends_with(" << test << ") = "
|
|
<< Switch(input1.ends_with(test)) << nl;
|
|
}
|
|
Info<<"input: " << input2 << nl;
|
|
for (const string& test : checks)
|
|
{
|
|
Info<< " ends_with(" << test << ") = "
|
|
<< Switch(input2.ends_with(test)) << nl;
|
|
}
|
|
|
|
Info<< nl;
|
|
Info<< "check ends_with as applied to field names:" << nl
|
|
<< "~~~~~~~~~~~~~~~~~" << nl;
|
|
|
|
string input3 = "field_0";
|
|
string input4 = "_0";
|
|
|
|
Info<<input3 << " ends_with(\"_0\") = "
|
|
<< Switch(input3.ends_with("_0")) << nl;
|
|
|
|
Info<<input4 << " ends_with(\"_0\") = "
|
|
<< Switch(input4.ends_with("_0")) << nl;
|
|
}
|
|
|
|
|
|
Info<< "\nEnd\n" << endl;
|
|
return 0;
|
|
}
|
|
|
|
|
|
// ************************************************************************* //
|