OilfieldToolsNet/opm-common
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Parser: rename and split canParseKeyword to isRecognizedKeyword

Browse Source 
which is more what the method does because the keyword can still
contain an error in its data which would make it non-parseable.

While at it, split the method into a "get keyword name from input
line" and "is a valid keyword name" part. (this will be needed later.)
This commit is contained in:
Andreas Lauser
2014-09-02 17:26:07 +02:00
committed by Joakim Hove
parent 6eb3421f38
commit fbf6008da4
8 changed files with 74 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
opm/parser/eclipse/IntegrationTests/IntegrationTests.cpp
View File

@@ -49,8 +49,8 @@ static ParserPtr createWWCTParser() {
BOOST_AUTO_TEST_CASE(parse_fileWithWWCTKeyword_deckReturned) {
boost::filesystem::path singleKeywordFile("testdata/integration_tests/wwct.data");
ParserPtr parser = createWWCTParser();
BOOST_CHECK( parser->canParseDeckKeyword("WWCT"));
BOOST_CHECK( parser->canParseDeckKeyword("SUMMARY"));
BOOST_CHECK( parser->isRecognizedKeyword("WWCT"));
BOOST_CHECK( parser->isRecognizedKeyword("SUMMARY"));
BOOST_CHECK_NO_THROW(DeckPtr deck = parser->parseFile(singleKeywordFile.string()));
}
@@ -63,8 +63,8 @@ BOOST_AUTO_TEST_CASE(parse_stringWithWWCTKeyword_deckReturned) {
" 'WELL-1' 'WELL-2' / -- Ehne mehne muh\n"
"/\n";
ParserPtr parser = createWWCTParser();
BOOST_CHECK( parser->canParseDeckKeyword("WWCT"));
BOOST_CHECK( parser->canParseDeckKeyword("SUMMARY"));
BOOST_CHECK( parser->isRecognizedKeyword("WWCT"));
BOOST_CHECK( parser->isRecognizedKeyword("SUMMARY"));
BOOST_CHECK_NO_THROW(DeckPtr deck = parser->parseString(wwctString));
}
@@ -79,8 +79,8 @@ BOOST_AUTO_TEST_CASE(parse_streamWithWWCTKeyword_deckReturned) {
std::shared_ptr<std::istream> wwctStream(new std::istringstream(wwctString));
ParserPtr parser = createWWCTParser();
BOOST_CHECK( parser->canParseDeckKeyword("WWCT"));
BOOST_CHECK( parser->canParseDeckKeyword("SUMMARY"));
BOOST_CHECK( parser->isRecognizedKeyword("WWCT"));
BOOST_CHECK( parser->isRecognizedKeyword("SUMMARY"));
BOOST_CHECK_NO_THROW(DeckPtr deck = parser->parseStream(wwctStream));
}
@@ -111,16 +111,16 @@ BOOST_AUTO_TEST_CASE(parser_internal_name_vs_deck_name) {
// internal names cannot appear in the deck if the deck names and/or deck regular
// match expressions are given
BOOST_CHECK(!parser->canParseDeckKeyword("WELL_PROBE"));
BOOST_CHECK(!parser->isRecognizedKeyword("WELL_PROBE"));
// an existing deck name
BOOST_CHECK(parser->canParseDeckKeyword("WWPR"));
BOOST_CHECK(parser->isRecognizedKeyword("WWPR"));
// a non-existing deck name
BOOST_CHECK(!parser->canParseDeckKeyword("WWPRFOO"));
BOOST_CHECK(!parser->isRecognizedKeyword("WWPRFOO"));
// user defined quantity. (regex needs to be used.)
BOOST_CHECK(parser->canParseDeckKeyword("WUFOO"));
BOOST_CHECK(parser->isRecognizedKeyword("WUFOO"));
}
static ParserPtr createBPRParser() {
@@ -202,8 +202,6 @@ BOOST_AUTO_TEST_CASE(parse_fileWithBPRKeyword_dataiscorrect) {
}
/***************** Testing non-recognized keywords ********************/
BOOST_AUTO_TEST_CASE(parse_unknownkeywordWithnonstrictparsing_keywordmarked) {
ParserPtr parser(new Parser());

6
opm/parser/eclipse/IntegrationTests/ParseACTION.cpp
View File

@@ -46,9 +46,9 @@ BOOST_AUTO_TEST_CASE( parse_ACTION_OK ) {
parser->addParserKeyword( DIMENS );
parser->addParserKeyword( THROW );
BOOST_REQUIRE( parser->canParseDeckKeyword( "DIMENS" ));
BOOST_REQUIRE( parser->canParseDeckKeyword( "WCONHIST" ));
BOOST_REQUIRE( parser->canParseDeckKeyword( "THROW" ));
BOOST_REQUIRE( parser->isRecognizedKeyword( "DIMENS" ));
BOOST_REQUIRE( parser->isRecognizedKeyword( "WCONHIST" ));
BOOST_REQUIRE( parser->isRecognizedKeyword( "THROW" ));
BOOST_REQUIRE_THROW( parser->parseFile( actionFile2.string() , false) , std::invalid_argument );

2
opm/parser/eclipse/IntegrationTests/ParseVFPPROD.cpp
View File

@@ -38,7 +38,7 @@ using namespace Opm;
BOOST_AUTO_TEST_CASE( parse_VFPPROD_OK ) {
ParserPtr parser(new Parser());
boost::filesystem::path file("testdata/integration_tests/VFPPROD/VFPPROD1");
BOOST_CHECK( parser->canParseDeckKeyword("VFPPROD"));
BOOST_CHECK( parser->isRecognizedKeyword("VFPPROD"));
DeckPtr deck = parser->parseFile(file.string());

19
opm/parser/eclipse/Parser/Parser.cpp
View File

@@ -152,9 +152,10 @@ namespace Opm {
return (m_wildCardKeywords.count(internalKeywordName) > 0);
}
bool Parser::canParseDeckKeyword( const std::string& deckKeywordName) const {
if (!ParserKeyword::validDeckName(deckKeywordName))
bool Parser::isRecognizedKeyword(const std::string& deckKeywordName) const {
if (!ParserKeyword::validDeckName(deckKeywordName)) {
return false;
}
if (m_deckParserKeywords.count(deckKeywordName) > 0)
return true;
@@ -285,8 +286,8 @@ namespace Opm {
} else {
if (verbose)
std::cout << parserState->rawKeyword->getKeywordName() << std::endl;
if (canParseDeckKeyword(parserState->rawKeyword->getKeywordName())) {
if (isRecognizedKeyword(parserState->rawKeyword->getKeywordName())) {
ParserKeywordConstPtr parserKeyword = getParserKeywordFromDeckName(parserState->rawKeyword->getKeywordName());
ParserKeywordActionEnum action = parserKeyword->getAction();
if (action == INTERNALIZE) {
@@ -330,8 +331,10 @@ namespace Opm {
throw std::invalid_argument("Input JSON object is not an array");
}
RawKeywordPtr Parser::createRawKeyword(const std::string & keywordString, std::shared_ptr<ParserState> parserState) const {
if (canParseDeckKeyword(keywordString)) {
RawKeywordPtr Parser::createRawKeyword(const std::string& initialLine, std::shared_ptr<ParserState> parserState) const {
std::string keywordString = ParserKeyword::getDeckName(initialLine);
if (isRecognizedKeyword(keywordString)) {
ParserKeywordConstPtr parserKeyword = getParserKeywordFromDeckName( keywordString );
ParserKeywordActionEnum action = parserKeyword->getAction();
@@ -398,7 +401,7 @@ namespace Opm {
}
} else {
if (parserState->rawKeyword->getSizeType() == Raw::UNKNOWN) {
if (canParseDeckKeyword(line)) {
if (isRecognizedKeyword(line)) {
parserState->rawKeyword->finalizeUnknownSize();
parserState->nextKeyword = line;
return true;
@@ -464,7 +467,7 @@ namespace Opm {
deck->initUnitSystem();
for (size_t index=0; index < deck->size(); ++index) {
DeckKeywordPtr deckKeyword = deck->getKeyword( index );
if (canParseDeckKeyword( deckKeyword->name())) {
if (isRecognizedKeyword( deckKeyword->name())) {
ParserKeywordConstPtr parserKeyword = getParserKeywordFromDeckName( deckKeyword->name() );
if (parserKeyword->hasDimension()) {
parserKeyword->applyUnitsToDeck(deck , deckKeyword);

2
opm/parser/eclipse/Parser/Parser.hpp
View File

@@ -55,7 +55,7 @@ namespace Opm {
void addParserKeyword(ParserKeywordConstPtr parserKeyword);
bool dropParserKeyword(const std::string& parserKeywordName);
bool canParseDeckKeyword( const std::string& deckKeywordName) const;
bool isRecognizedKeyword( const std::string& deckKeywordName) const;
ParserKeywordConstPtr getParserKeywordFromDeckName(const std::string& deckKeywordName) const;
std::vector<std::string> getAllDeckNames () const;

14
opm/parser/eclipse/Parser/ParserKeyword.cpp
View File

@@ -20,8 +20,6 @@
#include <string>
#include <stdexcept>
#include <opm/json/JsonObject.hpp>
#include <opm/parser/eclipse/Parser/ParserConst.hpp>
@@ -31,6 +29,7 @@
#include <opm/parser/eclipse/Parser/ParserStringItem.hpp>
#include <opm/parser/eclipse/Parser/ParserFloatItem.hpp>
#include <boost/algorithm/string.hpp>
namespace Opm {
@@ -231,6 +230,17 @@ namespace Opm {
return true;
}
std::string ParserKeyword::getDeckName(const std::string& rawString)
{
// only look at the first 8 characters (at most)
std::string result = rawString.substr(0, 8);
// remove any white space
boost::algorithm::trim(result);
return result;
}
bool ParserKeyword::validDeckName(const std::string& name) {
if (!validNameStart(name))
return false;

1
opm/parser/eclipse/Parser/ParserKeyword.hpp
View File

@@ -104,6 +104,7 @@ namespace Opm {
*/
static ParserKeywordPtr createFromJson(const Json::JsonObject& jsonConfig);
static std::string getDeckName(const std::string& rawString);
static bool validInternalName(const std::string& name);
static bool validDeckName(const std::string& name);
bool hasMatchRegex() const;

70
opm/parser/eclipse/Parser/tests/ParserTests.cpp
View File

@@ -55,7 +55,7 @@ BOOST_AUTO_TEST_CASE(addKeyword_keyword_doesntfail) {
BOOST_AUTO_TEST_CASE(canParseDeckKeyword_returnstrue) {
ParserPtr parser(new Parser());
parser->addParserKeyword(ParserKeyword::createDynamicSized("FJAS"));
BOOST_CHECK(parser->canParseDeckKeyword("FJAS"));
BOOST_CHECK(parser->isRecognizedKeyword("FJAS"));
}
@@ -93,11 +93,11 @@ BOOST_AUTO_TEST_CASE(getAllDeckNames_hasNoKeywords_returnsEmptyList) {
/************************ JSON config related tests **********************'*/
BOOST_AUTO_TEST_CASE(addParserKeywordJSON_canParseDEckkeyword_returnstrue) {
BOOST_AUTO_TEST_CASE(addParserKeywordJSON_isRecognizedKeyword_returnstrue) {
ParserPtr parser(new Parser());
Json::JsonObject jsonConfig("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}");
parser->addParserKeyword(ParserKeyword::createFromJson( jsonConfig ));
BOOST_CHECK(parser->canParseDeckKeyword("BPR"));
BOOST_CHECK(parser->isRecognizedKeyword("BPR"));
}
@@ -105,7 +105,7 @@ BOOST_AUTO_TEST_CASE(addParserKeywordJSON_size_isObject_allGood) {
ParserPtr parser(new Parser());
Json::JsonObject jsonConfig("{\"name\": \"EQUIXL\", \"sections\":[], \"size\" : {\"keyword\":\"EQLDIMS\" , \"item\" : \"NTEQUL\"}, \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}");
parser->addParserKeyword(ParserKeyword::createFromJson( jsonConfig ));
BOOST_CHECK(parser->canParseDeckKeyword("EQUIXL"));
BOOST_CHECK(parser->isRecognizedKeyword("EQUIXL"));
}
@@ -125,12 +125,12 @@ BOOST_AUTO_TEST_CASE(loadKeywordsJSON_noSectionsItem_throw) {
}
BOOST_AUTO_TEST_CASE(loadKeywordsJSON_canParseDeckKeyword_returnstrue) {
BOOST_AUTO_TEST_CASE(loadKeywordsJSON_isRecognizedKeyword_returnstrue) {
ParserPtr parser(new Parser());
Json::JsonObject jsonConfig( "[{\"name\" : \"BPR\" , \"size\" : 100, \"sections\":[\"SUMMARY\"], \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}]");
parser->loadKeywords( jsonConfig );
BOOST_CHECK(parser->canParseDeckKeyword("BPR"));
BOOST_CHECK(parser->isRecognizedKeyword("BPR"));
}
@@ -146,9 +146,9 @@ BOOST_AUTO_TEST_CASE(loadKeywordsJSON_manyKeywords_returnstrue) {
Json::JsonObject jsonConfig( "[{\"name\" : \"BPR\" , \"size\" : 100, \"sections\":[\"SUMMARY\"] , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}, {\"name\" : \"WWCT\", \"sections\":[\"SUMMARY\"], \"size\" : 0} , {\"name\" : \"EQUIL\", \"sections\":[\"PROPS\"], \"size\" : 0}]");
parser->loadKeywords( jsonConfig );
BOOST_CHECK(parser->canParseDeckKeyword("BPR"));
BOOST_CHECK(parser->canParseDeckKeyword("WWCT"));
BOOST_CHECK(parser->canParseDeckKeyword("EQUIL"));
BOOST_CHECK(parser->isRecognizedKeyword("BPR"));
BOOST_CHECK(parser->isRecognizedKeyword("WWCT"));
BOOST_CHECK(parser->isRecognizedKeyword("EQUIL"));
BOOST_CHECK_EQUAL( 3U , parser->size() );
}
@@ -184,7 +184,7 @@ BOOST_AUTO_TEST_CASE(loadKeywordFromFile_validKeyword_returnsTrueHasKeyword) {
boost::filesystem::path configFile("testdata/json/BPR");
BOOST_CHECK_EQUAL( true , parser->loadKeywordFromFile( configFile ));
BOOST_CHECK_EQUAL( 1U , parser->size() );
BOOST_CHECK_EQUAL( true , parser->canParseDeckKeyword("BPR") );
BOOST_CHECK_EQUAL( true , parser->isRecognizedKeyword("BPR") );
}
@@ -197,12 +197,12 @@ BOOST_AUTO_TEST_CASE(loadConfigFromDirectory_directoryDoesNotexist_throws) {
BOOST_AUTO_TEST_CASE(loadConfigFromDirectory_notRecursive_allNames) {
ParserPtr parser(new Parser(false));
BOOST_CHECK_EQUAL(false , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->isRecognizedKeyword("BPR"));
boost::filesystem::path configPath("testdata/config/directory1");
BOOST_CHECK_NO_THROW(parser->loadKeywordsFromDirectory( configPath, false));
BOOST_CHECK(parser->canParseDeckKeyword("WWCT"));
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->canParseDeckKeyword("DIMENS"));
BOOST_CHECK(parser->isRecognizedKeyword("WWCT"));
BOOST_CHECK_EQUAL(true , parser->isRecognizedKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->isRecognizedKeyword("DIMENS"));
}
@@ -210,49 +210,49 @@ BOOST_AUTO_TEST_CASE(loadConfigFromDirectory_notRecursive_strictNames) {
ParserPtr parser(new Parser(false));
boost::filesystem::path configPath("testdata/config/directory1");
BOOST_CHECK_NO_THROW(parser->loadKeywordsFromDirectory( configPath, false));
BOOST_CHECK(parser->canParseDeckKeyword("WWCT"));
BOOST_CHECK(parser->isRecognizedKeyword("WWCT"));
// the file name for the following keyword is "Bpr", but that
// does not matter
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->canParseDeckKeyword("DIMENS"));
BOOST_CHECK_EQUAL(true , parser->isRecognizedKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->isRecognizedKeyword("DIMENS"));
}
BOOST_AUTO_TEST_CASE(loadConfigFromDirectory_Recursive_allNames) {
ParserPtr parser(new Parser(false));
BOOST_CHECK_EQUAL(false , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->isRecognizedKeyword("BPR"));
boost::filesystem::path configPath("testdata/config/directory1");
BOOST_CHECK_NO_THROW(parser->loadKeywordsFromDirectory( configPath, true));
BOOST_CHECK(parser->canParseDeckKeyword("WWCT"));
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("DIMENS"));
BOOST_CHECK(parser->isRecognizedKeyword("WWCT"));
BOOST_CHECK_EQUAL(true , parser->isRecognizedKeyword("BPR"));
BOOST_CHECK_EQUAL(true , parser->isRecognizedKeyword("DIMENS"));
}
BOOST_AUTO_TEST_CASE(loadConfigFromDirectory_default) {
ParserPtr parser(new Parser(false));
BOOST_CHECK_EQUAL(false , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->isRecognizedKeyword("BPR"));
boost::filesystem::path configPath("testdata/config/directory1");
BOOST_CHECK_NO_THROW(parser->loadKeywordsFromDirectory( configPath ));
BOOST_CHECK(parser->canParseDeckKeyword("WWCT"));
BOOST_CHECK(parser->isRecognizedKeyword("WWCT"));
// the file name for the following keyword is "Bpr", but that
// does not matter
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("DIMENS"));
BOOST_CHECK_EQUAL(true , parser->isRecognizedKeyword("BPR"));
BOOST_CHECK_EQUAL(true , parser->isRecognizedKeyword("DIMENS"));
}
BOOST_AUTO_TEST_CASE(DropKeyword) {
ParserPtr parser(new Parser());
BOOST_CHECK_EQUAL(false , parser->dropParserKeyword("DoesNotHaveThis"));
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(true , parser->isRecognizedKeyword("BPR"));
BOOST_CHECK_EQUAL(true , parser->dropParserKeyword("BLOCK_PROBE"));
BOOST_CHECK_EQUAL(false , parser->dropParserKeyword("BLOCK_PROBE"));
BOOST_CHECK_EQUAL(false , parser->canParseDeckKeyword("BPR"));
BOOST_CHECK_EQUAL(false , parser->isRecognizedKeyword("BPR"));
BOOST_CHECK_EQUAL(true , parser->canParseDeckKeyword("TVDPX"));
BOOST_CHECK_EQUAL(true , parser->isRecognizedKeyword("TVDPX"));
BOOST_CHECK_EQUAL(true , parser->dropParserKeyword("TVDP"));
BOOST_CHECK_EQUAL(false , parser->canParseDeckKeyword("TVDPX"));
BOOST_CHECK_EQUAL(false , parser->isRecognizedKeyword("TVDPX"));
}
@@ -271,13 +271,13 @@ BOOST_AUTO_TEST_CASE(ReplaceKeyword) {
BOOST_AUTO_TEST_CASE(WildCardTest) {
ParserPtr parser(new Parser());
BOOST_CHECK(!parser->canParseDeckKeyword("TVDP*"));
BOOST_CHECK(!parser->canParseDeckKeyword("TVDP"));
BOOST_CHECK(parser->canParseDeckKeyword("TVDPXXX"));
BOOST_CHECK(!parser->canParseDeckKeyword("TVDPIAMTOOLONG"));
BOOST_CHECK(!parser->canParseDeckKeyword("TVD"));
BOOST_CHECK(!parser->isRecognizedKeyword("TVDP*"));
BOOST_CHECK(!parser->isRecognizedKeyword("TVDP"));
BOOST_CHECK(parser->isRecognizedKeyword("TVDPXXX"));
BOOST_CHECK(!parser->isRecognizedKeyword("TVDPIAMTOOLONG"));
BOOST_CHECK(!parser->isRecognizedKeyword("TVD"));
BOOST_CHECK(!parser->canParseDeckKeyword("TVDP"));
BOOST_CHECK(!parser->isRecognizedKeyword("TVDP"));
ParserKeywordConstPtr keyword1 = parser->getParserKeywordFromDeckName("TVDPA");
ParserKeywordConstPtr keyword2 = parser->getParserKeywordFromDeckName("TVDPBC");