void help(string syntax,dictionary<string> options) { //help options.add("--help","Prints this help"); //syntax log(); log("Syntax is:"); log(syntax.indent(1)); //option options.update(options.keys().text().justify_left().lines().me(),options.values().me()); log(); log("Options are:"); for(int i=0;i<options.count();i++) { auto& current=options.item(i); log(concat(current._first," ",current._second).indent(1)); } }
void Foam::sixDoFRigidBodyMotionState::write(dictionary& dict) const { dict.add("centreOfRotation", centreOfRotation_); dict.add("orientation", Q_); dict.add("velocity", v_); dict.add("acceleration", a_); dict.add("angularMomentum", pi_); dict.add("torque", tau_); }
// Add thisEntry to dictionary thisDict. bool addEntry ( dictionary& thisDict, entry& thisEntry, const entry& mergeEntry, const bool literalRE ) { bool changed = false; // Recursively merge sub-dictionaries // TODO: merge without copying if (thisEntry.isDict() && mergeEntry.isDict()) { if ( merge ( const_cast<dictionary&>(thisEntry.dict()), mergeEntry.dict(), literalRE ) ) { changed = true; } } else { // Should use in-place modification instead of adding thisDict.add(mergeEntry.clone(thisDict).ptr(), true); changed = true; } return changed; }
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 setScoped ( dictionary& dict, const word& keyword, const bool overwrite, entry* d ) { if (keyword[0] == ':') { // Go up to top level and recurse to find entries setScoped ( const_cast<dictionary&>(dict.topDict()), keyword.substr(1, keyword.size()-1), overwrite, d ); return; } else { string::size_type dotPos = keyword.find('.'); if (dotPos == string::npos) { // Non-scoped lookup if (overwrite) { dict.set(d); } else { dict.add(d, false); } return; } else { if (dotPos == 0) { // Starting with a '.'. Go up for every 2nd '.' found const dictionary* dictPtr = &dict; string::size_type begVar = dotPos + 1; string::const_iterator iter = keyword.begin() + begVar; string::size_type endVar = begVar; while ( iter != keyword.end() && *iter == '.' ) { ++iter; ++endVar; // Go to parent if (&dictPtr->parent() == &dictionary::null) { FatalIOErrorInFunction(dict) << "No parent of current dictionary" << " when searching for " << keyword.substr ( begVar, keyword.size() - begVar ) << exit(FatalIOError); } dictPtr = &dictPtr->parent(); } setScoped ( const_cast<dictionary&>(*dictPtr), keyword.substr(endVar), overwrite, d ); return; } else { // Extract the first word word firstWord = keyword.substr(0, dotPos); const entry* entPtr = dict.lookupScopedEntryPtr ( firstWord, false, // Recursive false ); if (!entPtr || !entPtr->isDict()) { FatalIOErrorInFunction(dict) << "keyword " << firstWord << " is undefined in dictionary " << dict.name() << " or is not a dictionary" << endl << "Valid keywords are " << dict.keys() << exit(FatalIOError); } const dictionary& firstDict = entPtr->dict(); setScoped ( const_cast<dictionary&>(firstDict), keyword.substr(dotPos, keyword.size()-dotPos), overwrite, d ); return; } } } }
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 ); } } } }