// from Istream
blockDescriptor::blockDescriptor
(
const pointField& blockMeshPoints,
const curvedEdgeList& edges,
Istream& is
)
:
blockMeshPoints_(blockMeshPoints),
blockShape_(is),
curvedEdges_(edges),
edgePoints_(12),
edgeWeights_(12),
n_(),
expand_(12),
zoneName_()
{
// Look at first token
token t(is);
is.putBack(t);
// Optional zone name
if (t.isWord())
{
zoneName_ = t.wordToken();
// Consume zoneName token
is >> t;
// New look-ahead
is >> t;
is.putBack(t);
}
void Foam::dimensioned<Type>::initialize(Istream& is)
{
token nextToken(is);
is.putBack(nextToken);
// Check if the original format is used in which the name is provided
// and reset the name to that read
if (nextToken.isWord())
{
is >> name_;
is >> nextToken;
is.putBack(nextToken);
}
Foam::autoPtr<Foam::entry> Foam::entry::New(Istream& is)
{
is.fatalCheck("entry::New(Istream&)");
keyType keyword;
// Get the next keyword and if invalid return false
if (!getKeyword(keyword, is))
{
return autoPtr<entry>(NULL);
}
else // Keyword starts entry ...
{
token nextToken(is);
is.putBack(nextToken);
if (nextToken == token::BEGIN_BLOCK)
{
return autoPtr<entry>
(
new dictionaryEntry(keyword, dictionary::null, is)
);
}
else
{
return autoPtr<entry>
(
new primitiveEntry(keyword, is)
);
}
}
}
Foam::autoPtr<Foam::blockVertex> Foam::blockVertex::New
(
const dictionary& dict,
const label index,
const searchableSurfaces& geometry,
Istream& is
)
{
if (debug)
{
InfoInFunction << "Constructing blockVertex" << endl;
}
token firstToken(is);
if (firstToken.isPunctuation() && firstToken.pToken() == token::BEGIN_LIST)
{
// Putback the opening bracket
is.putBack(firstToken);
return autoPtr<blockVertex>
(
new blockVertices::pointVertex(dict, index, geometry, is)
);
}
else if (firstToken.isWord())
{
const word faceType(firstToken.wordToken());
IstreamConstructorTable::iterator cstrIter =
IstreamConstructorTablePtr_->find(faceType);
if (cstrIter == IstreamConstructorTablePtr_->end())
{
FatalErrorInFunction
<< "Unknown blockVertex type "
<< faceType << nl << nl
<< "Valid blockVertex types are" << endl
<< IstreamConstructorTablePtr_->sortedToc()
<< abort(FatalError);
}
return autoPtr<blockVertex>(cstrIter()(dict, index, geometry, is));
}
else
{
FatalIOErrorInFunction(is)
<< "incorrect first token, expected <word> or '(', found "
<< firstToken.info()
<< exit(FatalIOError);
return autoPtr<blockVertex>(nullptr);
}
}
bool Foam::functionEntries::ifeqEntry::evaluate
(
const bool doIf,
DynamicList<filePos>& stack,
dictionary& parentDict,
Istream& is
)
{
while (!is.eof())
{
token t;
readToken(t, is);
if (t.isWord() && t.wordToken() == "#ifeq")
{
// Recurse to evaluate
execute(stack, parentDict, is);
}
else if (t.isWord() && t.wordToken() == "#if")
{
// Recurse to evaluate
ifEntry::execute(stack, parentDict, is);
}
else if
(
doIf
&& t.isWord()
&& (t.wordToken() == "#else" || t.wordToken() == "#elif")
)
{
// Now skip until #endif
skipUntil(stack, parentDict, "#endif", is);
stack.remove();
break;
}
else if (t.isWord() && t.wordToken() == "#endif")
{
stack.remove();
break;
}
else
{
is.putBack(t);
bool ok = entry::New(parentDict, is);
if (!ok)
{
return false;
}
}
}
return true;
}
Foam::splineEdge::splineEdge(const pointField& points, Istream& is)
:
curvedEdge(points, is),
CatmullRomSpline(appendEndPoints(points, start_, end_, pointField(is)))
{
token t(is);
is.putBack(t);
// compatibility - might also have start/end tangents - discard them
if (t == token::BEGIN_LIST)
{
vector tangent0Ignored(is);
vector tangent1Ignored(is);
}
}
bool Foam::entry::New(dictionary& parentDict, Istream& is)
{
is.fatalCheck("entry::New(const dictionary& parentDict, Istream&)");
keyType keyword;
// Get the next keyword and if invalid return false
if (!getKeyword(keyword, is))
{
return false;
}
else // Keyword starts entry ...
{
if
(
!disableFunctionEntries
&& keyword[0] == '#'
) // ... Function entry
{
word functionName = keyword(1, keyword.size()-1);
return functionEntry::execute(functionName, parentDict, is);
}
else if
(
!disableFunctionEntries
&& keyword[0] == '$'
) // ... Substitution entry
{
token nextToken(is);
is.putBack(nextToken);
if (keyword.size() > 2 && keyword[1] == token::BEGIN_BLOCK)
{
// Recursive substitution mode. Replace between {} with
// expansion and then let standard variable expansion deal
// with rest.
string s(keyword(2, keyword.size()-3));
// Substitute dictionary and environment variables. Do not allow
// empty substitutions.
stringOps::inplaceExpand(s, parentDict, true, false);
keyword.std::string::replace(1, keyword.size()-1, s);
}
if (nextToken == token::BEGIN_BLOCK)
{
word varName = keyword(1, keyword.size()-1);
// lookup the variable name in the given dictionary
const entry* ePtr = parentDict.lookupScopedEntryPtr
(
varName,
true,
true
);
if (ePtr)
{
// Read as primitiveEntry
const keyType newKeyword(ePtr->stream());
return parentDict.add
(
new dictionaryEntry(newKeyword, parentDict, is),
false
);
}
else
{
FatalIOErrorInFunction(is)
<< "Attempt to use undefined variable " << varName
<< " as keyword"
<< exit(FatalIOError);
return false;
}
}
else
{
parentDict.substituteScopedKeyword(keyword);
}
return true;
}
else if
(
!disableFunctionEntries
&& keyword == "include"
) // ... For backward compatibility
{
return functionEntries::includeEntry::execute(parentDict, is);
}
else // ... Data entries
{
token nextToken(is);
is.putBack(nextToken);
// Deal with duplicate entries
bool mergeEntry = false;
// See (using exact match) if entry already present
entry* existingPtr = parentDict.lookupEntryPtr
(
keyword,
false,
false
);
if (existingPtr)
{
if (functionEntries::inputModeEntry::merge())
{
mergeEntry = true;
}
else if (functionEntries::inputModeEntry::overwrite())
{
// clear dictionary so merge acts like overwrite
if (existingPtr->isDict())
{
existingPtr->dict().clear();
}
mergeEntry = true;
}
else if (functionEntries::inputModeEntry::protect())
{
// read and discard the entry
if (nextToken == token::BEGIN_BLOCK)
{
dictionaryEntry dummy(keyword, parentDict, is);
}
else
{
primitiveEntry dummy(keyword, parentDict, is);
}
return true;
}
else if (functionEntries::inputModeEntry::error())
{
FatalIOErrorInFunction(is)
<< "ERROR! duplicate entry: " << keyword
<< exit(FatalIOError);
return false;
}
}
if (nextToken == token::BEGIN_BLOCK)
{
return parentDict.add
(
new dictionaryEntry(keyword, parentDict, is),
mergeEntry
);
}
else
{
return parentDict.add
(
new primitiveEntry(keyword, parentDict, is),
mergeEntry
);
}
}
}
}
void Foam::LPtrList<LListBase, T>::read(Istream& is, const INew& iNew)
{
is.fatalCheck
(
"LPtrList<LListBase, T>::read(Istream&, const INew&)"
);
token firstToken(is);
is.fatalCheck
(
"LPtrList<LListBase, T>::read(Istream&, const INew&) : "
"reading first token"
);
if (firstToken.isLabel())
{
label s = firstToken.labelToken();
// Read beginning of contents
char delimiter = is.readBeginList("LPtrList<LListBase, T>");
if (s)
{
if (delimiter == token::BEGIN_LIST)
{
for (label i=0; i<s; ++i)
{
this->append(iNew(is).ptr());
is.fatalCheck
(
"LPtrList<LListBase, T>::read(Istream&, const INew&) : "
"reading entry"
);
}
}
else
{
T* tPtr = iNew(is).ptr();
this->append(tPtr);
is.fatalCheck
(
"LPtrList<LListBase, T>::read(Istream&, const INew&) : "
"reading entry"
);
for (label i=1; i<s; ++i)
{
this->append(tPtr->clone().ptr());
}
}
}
// Read end of contents
is.readEndList("LPtrList<LListBase, T>");
}
else if (firstToken.isPunctuation())
{
if (firstToken.pToken() != token::BEGIN_LIST)
{
FatalIOErrorIn
(
"LPtrList<LListBase, T>::read(Istream&, const INew&)",
is
) << "incorrect first token, '(', found " << firstToken.info()
<< exit(FatalIOError);
}
token lastToken(is);
is.fatalCheck("LPtrList<LListBase, T>::read(Istream&, const INew&)");
while
(
!(
lastToken.isPunctuation()
&& lastToken.pToken() == token::END_LIST
)
)
{
is.putBack(lastToken);
this->append(iNew(is).ptr());
is >> lastToken;
is.fatalCheck
(
"LPtrList<LListBase, T>::read(Istream&, const INew&)"
);
}
}
else
{
bool Foam::entry::New(dictionary& parentDict, Istream& is)
{
is.fatalCheck("entry::New(const dictionary& parentDict, Istream&)");
keyType keyword;
// Get the next keyword and if invalid return false
if (!getKeyword(keyword, is))
{
return false;
}
else // Keyword starts entry ...
{
if (keyword[0] == '#') // ... Function entry
{
word functionName = keyword(1, keyword.size()-1);
return functionEntry::execute(functionName, parentDict, is);
}
else if (keyword[0] == '$') // ... Substitution entry
{
parentDict.substituteKeyword(keyword);
return true;
}
else if (keyword == "include") // ... For backward compatibility
{
return functionEntries::includeEntry::execute(parentDict, is);
}
else // ... Data entries
{
token nextToken(is);
is.putBack(nextToken);
// Deal with duplicate entries
bool mergeEntry = false;
// See (using exact match) if entry already present
entry* existingPtr = parentDict.lookupEntryPtr
(
keyword,
false,
false
);
if (existingPtr)
{
if (functionEntries::inputModeEntry::merge())
{
mergeEntry = true;
}
else if (functionEntries::inputModeEntry::overwrite())
{
// clear dictionary so merge acts like overwrite
if (existingPtr->isDict())
{
existingPtr->dict().clear();
}
mergeEntry = true;
}
else if (functionEntries::inputModeEntry::protect())
{
// read and discard the entry
if (nextToken == token::BEGIN_BLOCK)
{
dictionaryEntry dummy(keyword, parentDict, is);
}
else
{
primitiveEntry dummy(keyword, parentDict, is);
}
return true;
}
else if (functionEntries::inputModeEntry::error())
{
FatalIOErrorIn
(
"entry::New(const dictionary& parentDict, Istream&)",
is
)
<< "ERROR! duplicate entry: " << keyword
<< exit(FatalIOError);
return false;
}
}
if (nextToken == token::BEGIN_BLOCK)
{
return parentDict.add
(
new dictionaryEntry(keyword, parentDict, is),
mergeEntry
);
}
else
{
return parentDict.add
(
new primitiveEntry(keyword, parentDict, is),
mergeEntry
);
}
}
}
}
