diff --git a/opm/parser/eclipse/Deck/tests/DeckRecordTests.cpp b/opm/parser/eclipse/Deck/tests/DeckRecordTests.cpp index e66056142..9eb7f0f07 100644 --- a/opm/parser/eclipse/Deck/tests/DeckRecordTests.cpp +++ b/opm/parser/eclipse/Deck/tests/DeckRecordTests.cpp @@ -100,15 +100,14 @@ BOOST_AUTO_TEST_CASE(get_byNameNonExisting_throws) { } BOOST_AUTO_TEST_CASE(StringsWithSpaceOK) { - ParserStringItemPtr itemString(new ParserStringItem(std::string("STRINGITEM1"))); - ParserRecordPtr record1(new ParserRecord()); + auto itemString = std::make_shared< ParserStringItem >(std::string("STRINGITEM1")); + ParserRecord record1; RawRecord rawRecord( " ' VALUE ' " ); ParseContext parseContext; MessageContainer msgContainer; - record1->addItem( itemString ); + record1.addItem( itemString ); - const auto deckRecord = record1->parse( parseContext , msgContainer, rawRecord ); + const auto deckRecord = record1.parse( parseContext , msgContainer, rawRecord ); BOOST_CHECK_EQUAL(" VALUE " , deckRecord.getItem(0).get< std::string >(0)); } - diff --git a/opm/parser/eclipse/EclipseState/EclipseState.hpp b/opm/parser/eclipse/EclipseState/EclipseState.hpp index d9cdb878f..abdac49bf 100644 --- a/opm/parser/eclipse/EclipseState/EclipseState.hpp +++ b/opm/parser/eclipse/EclipseState/EclipseState.hpp @@ -134,9 +134,6 @@ namespace Opm { MessageContainer m_messageContainer; }; - - typedef std::shared_ptr EclipseStatePtr; - typedef std::shared_ptr EclipseStateConstPtr; } #endif // OPM_ECLIPSE_STATE_HPP diff --git a/opm/parser/eclipse/EclipseState/Schedule/GroupTree.cpp b/opm/parser/eclipse/EclipseState/Schedule/GroupTree.cpp index 116d517bd..6406be9f7 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/GroupTree.cpp +++ b/opm/parser/eclipse/EclipseState/Schedule/GroupTree.cpp @@ -44,14 +44,14 @@ namespace Opm { throw std::domain_error("Error, trying to add node with the same name as the root, offending name: " + childName); } - GroupTreeNodePtr newParentNode = getNode(parentName); + std::shared_ptr< GroupTreeNode > newParentNode = getNode(parentName); if (!newParentNode) { newParentNode = m_root->addChildGroup(parentName); } - GroupTreeNodePtr childNodeInTree = getNode(childName); + std::shared_ptr< GroupTreeNode > childNodeInTree = getNode(childName); if (childNodeInTree) { - GroupTreeNodePtr currentParent = getParent(childName); + std::shared_ptr< GroupTreeNode > currentParent = getParent(childName); currentParent->removeChild(childNodeInTree); newParentNode->addChildGroup(childNodeInTree); } else { @@ -59,80 +59,80 @@ namespace Opm { } } - GroupTreeNodePtr GroupTree::getNode(const std::string& nodeName) const { - GroupTreeNodePtr current = m_root; + std::shared_ptr< GroupTreeNode > GroupTree::getNode(const std::string& nodeName) const { + std::shared_ptr< GroupTreeNode > current = m_root; return getNode(nodeName, current); } - GroupTreeNodePtr GroupTree::getNode(const std::string& nodeName, GroupTreeNodePtr current) const { + std::shared_ptr< GroupTreeNode > GroupTree::getNode(const std::string& nodeName, std::shared_ptr< GroupTreeNode > current) const { if (current->name() == nodeName) { return current; } else { - std::map::const_iterator iter = current->begin(); + std::map>::const_iterator iter = current->begin(); while (iter != current->end()) { - GroupTreeNodePtr result = getNode(nodeName, (*iter).second); + std::shared_ptr< GroupTreeNode > result = getNode(nodeName, (*iter).second); if (result) { return result; } ++iter; } - return GroupTreeNodePtr(); + return std::shared_ptr< GroupTreeNode >(); } } - std::vector GroupTree::getNodes() const { - std::vector nodes; + std::vector> GroupTree::getNodes() const { + std::vector> nodes; nodes.push_back(m_root); getNodes(m_root, nodes); return nodes; } - void GroupTree::getNodes(GroupTreeNodePtr fromNode, std::vector& nodes) const { - std::map::const_iterator iter = fromNode->begin(); + void GroupTree::getNodes(std::shared_ptr< GroupTreeNode > fromNode, std::vector>& nodes) const { + std::map >::const_iterator iter = fromNode->begin(); while (iter != fromNode->end()) { - GroupTreeNodePtr child = (*iter).second; + std::shared_ptr< GroupTreeNode > child = (*iter).second; nodes.push_back(child); getNodes(child, nodes); ++iter; } } - GroupTreeNodePtr GroupTree::getParent(const std::string& childName) const { - GroupTreeNodePtr currentChild = m_root; - return getParent(childName, currentChild, GroupTreeNodePtr()); + std::shared_ptr< GroupTreeNode > GroupTree::getParent(const std::string& childName) const { + std::shared_ptr< GroupTreeNode > currentChild = m_root; + return getParent(childName, currentChild, std::shared_ptr< GroupTreeNode >()); } - GroupTreeNodePtr GroupTree::getParent(const std::string& childName, GroupTreeNodePtr currentChild, GroupTreeNodePtr parent) const { + std::shared_ptr< GroupTreeNode > GroupTree::getParent(const std::string& childName, std::shared_ptr< GroupTreeNode > currentChild, std::shared_ptr< GroupTreeNode > parent) const { if (currentChild->name() == childName) { return parent; } else { - std::map::const_iterator iter = currentChild->begin(); + std::map>::const_iterator iter = currentChild->begin(); while (iter != currentChild->end()) { - GroupTreeNodePtr result = getParent(childName, (*iter).second, currentChild); + std::shared_ptr< GroupTreeNode > result = getParent(childName, (*iter).second, currentChild); if (result) { return result; } ++iter; } - return GroupTreeNodePtr(); + return std::shared_ptr< GroupTreeNode >(); } } - GroupTreePtr GroupTree::deepCopy() const { - GroupTreePtr newTree(new GroupTree()); - GroupTreeNodePtr currentOriginNode = m_root; - GroupTreeNodePtr currentNewNode = newTree->getNode("FIELD"); + std::shared_ptr< GroupTree > GroupTree::deepCopy() const { + std::shared_ptr< GroupTree > newTree(new GroupTree()); + std::shared_ptr< GroupTreeNode > currentOriginNode = m_root; + std::shared_ptr< GroupTreeNode > currentNewNode = newTree->getNode("FIELD"); deepCopy(currentOriginNode, currentNewNode); return newTree; } - void GroupTree::deepCopy(GroupTreeNodePtr origin, GroupTreeNodePtr copy) const { - std::map::const_iterator iter = origin->begin(); + void GroupTree::deepCopy(std::shared_ptr< GroupTreeNode > origin, std::shared_ptr< GroupTreeNode > copy) const { + std::map >::const_iterator iter = origin->begin(); while (iter != origin->end()) { - GroupTreeNodePtr originChild = (*iter).second; - GroupTreeNodePtr copyChild = copy->addChildGroup(originChild->name()); + std::shared_ptr< GroupTreeNode > originChild = (*iter).second; + std::shared_ptr< GroupTreeNode > copyChild = copy->addChildGroup(originChild->name()); deepCopy(originChild, copyChild); ++iter; } @@ -144,11 +144,11 @@ namespace Opm { os << "End of tree" << std::endl; } - void GroupTree::printTree(std::ostream &os , GroupTreeNodePtr fromNode) const { + void GroupTree::printTree(std::ostream &os , std::shared_ptr< GroupTreeNode > fromNode) const { os << fromNode->name() << "(" << fromNode.get() << ")"; - std::map::const_iterator iter = fromNode->begin(); + std::map >::const_iterator iter = fromNode->begin(); while (iter != fromNode->end()) { - GroupTreeNodePtr child = (*iter).second; + const auto& child = (*iter).second; os << "<-" << child->name() << "(" << child.get() << ")" << std::endl; printTree(os , child); ++iter; diff --git a/opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp b/opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp index bcb16139b..f6d0d3835 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp +++ b/opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp @@ -36,9 +36,9 @@ namespace Opm { void updateTree(const std::string& childName); void updateTree(const std::string& childName, const std::string& parentName); - GroupTreeNodePtr getNode(const std::string& nodeName) const; - std::vector getNodes() const; - GroupTreeNodePtr getParent(const std::string& childName) const; + std::shared_ptr< GroupTreeNode > getNode(const std::string& nodeName) const; + std::vector> getNodes() const; + std::shared_ptr< GroupTreeNode > getParent(const std::string& childName) const; std::shared_ptr deepCopy() const; void printTree(std::ostream &os) const; @@ -53,17 +53,15 @@ namespace Opm { private: - GroupTreeNodePtr m_root; - GroupTreeNodePtr getNode(const std::string& nodeName, GroupTreeNodePtr current) const; - GroupTreeNodePtr getParent(const std::string& childName, GroupTreeNodePtr currentChild, GroupTreeNodePtr parent) const; + std::shared_ptr< GroupTreeNode > m_root; + std::shared_ptr< GroupTreeNode > getNode(const std::string& nodeName, std::shared_ptr< GroupTreeNode > current) const; + std::shared_ptr< GroupTreeNode > getParent(const std::string& childName, std::shared_ptr< GroupTreeNode > currentChild, std::shared_ptr< GroupTreeNode > parent) const; - void getNodes(GroupTreeNodePtr fromNode, std::vector& nodes) const; - void deepCopy(GroupTreeNodePtr origin, GroupTreeNodePtr copy) const; - void printTree(std::ostream &os , GroupTreeNodePtr fromNode) const; + void getNodes(std::shared_ptr< GroupTreeNode > fromNode, + std::vector< std::shared_ptr< const GroupTreeNode > >& nodes) const; + void deepCopy(std::shared_ptr< GroupTreeNode > origin, std::shared_ptr< GroupTreeNode > copy) const; + void printTree(std::ostream &os , std::shared_ptr< GroupTreeNode > fromNode) const; }; - - typedef std::shared_ptr GroupTreePtr; - typedef std::shared_ptr GroupTreeConstPtr; } #endif /* GROUPTREE_HPP */ diff --git a/opm/parser/eclipse/EclipseState/Schedule/GroupTreeNode.cpp b/opm/parser/eclipse/EclipseState/Schedule/GroupTreeNode.cpp index 7a2c31124..a50ba6550 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/GroupTreeNode.cpp +++ b/opm/parser/eclipse/EclipseState/Schedule/GroupTreeNode.cpp @@ -30,11 +30,11 @@ namespace Opm { return m_name; } - GroupTreeNodePtr GroupTreeNode::addChildGroup(const std::string& childName) { + std::shared_ptr< GroupTreeNode > GroupTreeNode::addChildGroup(const std::string& childName) { if (hasChildGroup(childName)) { throw std::invalid_argument("Child group with name \"" + childName + "\"already exists."); } - GroupTreeNodePtr child(new GroupTreeNode(childName)); + std::shared_ptr< GroupTreeNode > child(new GroupTreeNode(childName)); m_childGroups[childName] = child; return child; } @@ -47,7 +47,7 @@ namespace Opm { } - void GroupTreeNode::removeChild(GroupTreeNodePtr child) { + void GroupTreeNode::removeChild(std::shared_ptr< GroupTreeNode > child) { if (!hasChildGroup(child->name())) { throw std::invalid_argument("The node " + m_name + " does not have a child named " + child->name()); } @@ -58,15 +58,15 @@ namespace Opm { return m_childGroups.find(childName) != m_childGroups.end(); } - GroupTreeNodePtr GroupTreeNode::getChildGroup(const std::string& childName) { + std::shared_ptr< GroupTreeNode > GroupTreeNode::getChildGroup(const std::string& childName) { if (hasChildGroup(childName)) { return m_childGroups[childName]; } throw std::invalid_argument("Child group with name \"" + childName + "\" does not exist."); } - GroupTreeNodePtr GroupTreeNode::createFieldNode() { - return GroupTreeNodePtr(new GroupTreeNode("FIELD")); + std::shared_ptr< GroupTreeNode > GroupTreeNode::createFieldNode() { + return std::shared_ptr< GroupTreeNode >(new GroupTreeNode("FIELD")); } std::map >::const_iterator GroupTreeNode::begin() const { diff --git a/opm/parser/eclipse/EclipseState/Schedule/GroupTreeNode.hpp b/opm/parser/eclipse/EclipseState/Schedule/GroupTreeNode.hpp index 7b64f1919..771a0d8f5 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/GroupTreeNode.hpp +++ b/opm/parser/eclipse/EclipseState/Schedule/GroupTreeNode.hpp @@ -49,9 +49,6 @@ namespace Opm { std::string m_name; std::map > m_childGroups; }; - - typedef std::shared_ptr GroupTreeNodePtr; - typedef std::shared_ptr GroupTreeNodeConstPtr; } #endif /* GROUPTREENODE_HPP */ diff --git a/opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp b/opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp index 1819b03fe..c4779cc00 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp +++ b/opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp @@ -153,8 +153,6 @@ namespace Opm static bool convertEclipseStringToBool(const std::string& eclipseString); }; - typedef std::shared_ptr SchedulePtr; - typedef std::shared_ptr ScheduleConstPtr; } #endif diff --git a/opm/parser/eclipse/EclipseState/Schedule/tests/GroupTreeNodeTests.cpp b/opm/parser/eclipse/EclipseState/Schedule/tests/GroupTreeNodeTests.cpp index 4b9f40f6f..72d0cf640 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/tests/GroupTreeNodeTests.cpp +++ b/opm/parser/eclipse/EclipseState/Schedule/tests/GroupTreeNodeTests.cpp @@ -29,50 +29,50 @@ using namespace Opm; BOOST_AUTO_TEST_CASE(CreateFieldNode) { - GroupTreeNodePtr node = GroupTreeNode::createFieldNode(); + auto node = GroupTreeNode::createFieldNode(); BOOST_CHECK_EQUAL("FIELD", node->name()); } BOOST_AUTO_TEST_CASE(CreateChild_WithFieldParent_ParentHasChild) { - GroupTreeNodePtr fieldNode = GroupTreeNode::createFieldNode(); + auto fieldNode = GroupTreeNode::createFieldNode(); BOOST_CHECK(!fieldNode->hasChildGroup("Child")); - GroupTreeNodePtr child = fieldNode->addChildGroup("Child"); + auto child = fieldNode->addChildGroup("Child"); BOOST_REQUIRE(fieldNode->hasChildGroup("Child")); BOOST_CHECK_EQUAL(child, fieldNode->getChildGroup("Child")); } BOOST_AUTO_TEST_CASE(CreateChildGroup_ChildExists_Throws) { - GroupTreeNodePtr fieldNode = GroupTreeNode::createFieldNode(); - GroupTreeNodePtr child = fieldNode->addChildGroup("Child"); + auto fieldNode = GroupTreeNode::createFieldNode(); + auto child = fieldNode->addChildGroup("Child"); BOOST_CHECK_THROW(fieldNode->addChildGroup("Child"), std::invalid_argument); } BOOST_AUTO_TEST_CASE(GetChildGroup_ChildNotExisting_Throws) { - GroupTreeNodePtr fieldNode = GroupTreeNode::createFieldNode(); - GroupTreeNodePtr child = fieldNode->addChildGroup("Child2"); + auto fieldNode = GroupTreeNode::createFieldNode(); + auto child = fieldNode->addChildGroup("Child2"); BOOST_CHECK_THROW(fieldNode->getChildGroup("Child"), std::invalid_argument); } BOOST_AUTO_TEST_CASE(RemoveChild_ChildNonExisting_Throws) { - GroupTreeNodePtr fieldNodeDummy = GroupTreeNode::createFieldNode(); - GroupTreeNodePtr fieldNode = GroupTreeNode::createFieldNode(); - GroupTreeNodePtr child = fieldNode->addChildGroup("Child1"); + auto fieldNodeDummy = GroupTreeNode::createFieldNode(); + auto fieldNode = GroupTreeNode::createFieldNode(); + auto child = fieldNode->addChildGroup("Child1"); BOOST_CHECK_THROW(fieldNode->removeChild(fieldNodeDummy), std::invalid_argument); } BOOST_AUTO_TEST_CASE(RemoveChild_RemoveTwice_Throws) { - GroupTreeNodePtr fieldNodeDummy = GroupTreeNode::createFieldNode(); - GroupTreeNodePtr fieldNode = GroupTreeNode::createFieldNode(); - GroupTreeNodePtr child = fieldNode->addChildGroup("Child1"); + auto fieldNodeDummy = GroupTreeNode::createFieldNode(); + auto fieldNode = GroupTreeNode::createFieldNode(); + auto child = fieldNode->addChildGroup("Child1"); BOOST_CHECK_NO_THROW(fieldNode->removeChild(child));; BOOST_CHECK_THROW(fieldNode->removeChild(child), std::invalid_argument); } BOOST_AUTO_TEST_CASE(RemoveChild_ChildExists_ChildRemoved) { - GroupTreeNodePtr fieldNode = GroupTreeNode::createFieldNode(); - GroupTreeNodePtr child = fieldNode->addChildGroup("Child1"); + auto fieldNode = GroupTreeNode::createFieldNode(); + auto child = fieldNode->addChildGroup("Child1"); BOOST_CHECK_NO_THROW(fieldNode->removeChild(child)); BOOST_CHECK(!fieldNode->hasChildGroup("Child1")); } diff --git a/opm/parser/eclipse/EclipseState/Schedule/tests/GroupTreeTests.cpp b/opm/parser/eclipse/EclipseState/Schedule/tests/GroupTreeTests.cpp index 91338de19..45f86c9c5 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/tests/GroupTreeTests.cpp +++ b/opm/parser/eclipse/EclipseState/Schedule/tests/GroupTreeTests.cpp @@ -37,7 +37,7 @@ BOOST_AUTO_TEST_CASE(CreateGroupTree_DefaultConstructor_HasFieldNode) { BOOST_AUTO_TEST_CASE(GetNode_NonExistingNode_ReturnsNull) { GroupTree tree; - BOOST_CHECK_EQUAL(GroupTreeNodePtr(), tree.getNode("Non-existing")); + BOOST_CHECK(!tree.getNode("Non-existing")); } BOOST_AUTO_TEST_CASE(GetNodeAndParent_AllOK) { @@ -46,9 +46,9 @@ BOOST_AUTO_TEST_CASE(GetNodeAndParent_AllOK) { tree.updateTree("PARENT", "GRANDPARENT"); tree.updateTree("GRANDCHILD", "PARENT"); - GroupTreeNodePtr grandchild = tree.getNode("GRANDCHILD"); + auto grandchild = tree.getNode("GRANDCHILD"); BOOST_CHECK(grandchild); - GroupTreeNodePtr parent = tree.getParent("GRANDCHILD"); + auto parent = tree.getParent("GRANDCHILD"); BOOST_CHECK_EQUAL("PARENT", parent->name()); BOOST_CHECK(parent->hasChildGroup("GRANDCHILD")); } @@ -57,7 +57,7 @@ BOOST_AUTO_TEST_CASE(UpdateTree_ParentNotSpecified_AddedUnderField) { GroupTree tree; tree.updateTree("CHILD_OF_FIELD"); BOOST_CHECK(tree.getNode("CHILD_OF_FIELD")); - GroupTreeNodePtr rootNode = tree.getNode("FIELD"); + auto rootNode = tree.getNode("FIELD"); BOOST_CHECK(rootNode->hasChildGroup("CHILD_OF_FIELD")); } @@ -65,7 +65,7 @@ BOOST_AUTO_TEST_CASE(UpdateTree_ParentIsField_AddedUnderField) { GroupTree tree; tree.updateTree("CHILD_OF_FIELD", "FIELD"); BOOST_CHECK(tree.getNode("CHILD_OF_FIELD")); - GroupTreeNodePtr rootNode = tree.getNode("FIELD"); + auto rootNode = tree.getNode("FIELD"); BOOST_CHECK(rootNode->hasChildGroup("CHILD_OF_FIELD")); } @@ -73,9 +73,9 @@ BOOST_AUTO_TEST_CASE(UpdateTree_ParentNotAdded_ChildAndParentAdded) { GroupTree tree; tree.updateTree("CHILD", "NEWPARENT"); BOOST_CHECK(tree.getNode("CHILD")); - GroupTreeNodePtr rootNode = tree.getNode("FIELD"); + auto rootNode = tree.getNode("FIELD"); BOOST_CHECK(rootNode->hasChildGroup("NEWPARENT")); - GroupTreeNodePtr newParent = tree.getNode("NEWPARENT"); + auto newParent = tree.getNode("NEWPARENT"); BOOST_CHECK(newParent->hasChildGroup("CHILD")); } @@ -93,12 +93,12 @@ BOOST_AUTO_TEST_CASE(UpdateTree_ChildExists_ChildMoved) { tree.updateTree("GRANDCHILD1", "THECHILD"); tree.updateTree("GRANDCHILD2", "THECHILD"); - GroupTreeNodePtr oldParent = tree.getNode("OLDPARENT"); + auto oldParent = tree.getNode("OLDPARENT"); BOOST_CHECK(oldParent->hasChildGroup("THECHILD")); - GroupTreeNodePtr theChild = oldParent->getChildGroup("THECHILD"); + auto theChild = oldParent->getChildGroup("THECHILD"); BOOST_CHECK(theChild->hasChildGroup("GRANDCHILD1")); - GroupTreeNodePtr newParent = tree.getNode("NEWPARENT"); + auto newParent = tree.getNode("NEWPARENT"); BOOST_CHECK(!newParent->hasChildGroup("THECHILD")); tree.updateTree("THECHILD", "NEWPARENT"); @@ -111,54 +111,54 @@ BOOST_AUTO_TEST_CASE(UpdateTree_ChildExists_ChildMoved) { } BOOST_AUTO_TEST_CASE(DeepCopy_TreeWithChildren_ObjectsDifferContentMatch) { - GroupTreePtr tree(new GroupTree()); - tree->updateTree("L1CHILD1", "FIELD"); - tree->updateTree("L1CHILD2", "FIELD"); - tree->updateTree("L2CHILD1", "L1CHILD1"); - tree->updateTree("L2CHILD2", "L1CHILD1"); - tree->updateTree("L3CHILD1", "L2CHILD1"); + GroupTree tree; + tree.updateTree("L1CHILD1", "FIELD"); + tree.updateTree("L1CHILD2", "FIELD"); + tree.updateTree("L2CHILD1", "L1CHILD1"); + tree.updateTree("L2CHILD2", "L1CHILD1"); + tree.updateTree("L3CHILD1", "L2CHILD1"); - GroupTreePtr copiedTree = tree->deepCopy(); - GroupTreeNodePtr fieldNodeCopy = copiedTree->getNode("FIELD"); - GroupTreeNodePtr fieldNodeOriginal = tree->getNode("FIELD"); + auto copiedTree = tree.deepCopy(); + auto fieldNodeCopy = copiedTree->getNode("FIELD"); + auto fieldNodeOriginal = tree.getNode("FIELD"); BOOST_CHECK(!(fieldNodeCopy == fieldNodeOriginal)); BOOST_CHECK_EQUAL(fieldNodeCopy->name(), fieldNodeOriginal->name()); - GroupTreeNodePtr L1CHILD1NodeCopy = fieldNodeCopy->getChildGroup("L1CHILD1"); - GroupTreeNodePtr L1CHILD1NodeOriginal = fieldNodeOriginal->getChildGroup("L1CHILD1"); + auto L1CHILD1NodeCopy = fieldNodeCopy->getChildGroup("L1CHILD1"); + auto L1CHILD1NodeOriginal = fieldNodeOriginal->getChildGroup("L1CHILD1"); BOOST_CHECK(!(L1CHILD1NodeCopy == L1CHILD1NodeOriginal)); BOOST_CHECK_EQUAL(L1CHILD1NodeCopy->name(), L1CHILD1NodeOriginal->name()); - GroupTreeNodePtr L1CHILD2NodeCopy = fieldNodeCopy->getChildGroup("L1CHILD2"); - GroupTreeNodePtr L1CHILD2NodeOriginal = fieldNodeOriginal->getChildGroup("L1CHILD2"); + auto L1CHILD2NodeCopy = fieldNodeCopy->getChildGroup("L1CHILD2"); + auto L1CHILD2NodeOriginal = fieldNodeOriginal->getChildGroup("L1CHILD2"); BOOST_CHECK(!(L1CHILD2NodeCopy == L1CHILD2NodeOriginal)); BOOST_CHECK_EQUAL(L1CHILD2NodeCopy->name(), L1CHILD2NodeOriginal->name()); - GroupTreeNodePtr L2CHILD1NodeCopy = L1CHILD1NodeCopy->getChildGroup("L2CHILD1"); - GroupTreeNodePtr L2CHILD1NodeOriginal = L1CHILD1NodeOriginal->getChildGroup("L2CHILD1"); + auto L2CHILD1NodeCopy = L1CHILD1NodeCopy->getChildGroup("L2CHILD1"); + auto L2CHILD1NodeOriginal = L1CHILD1NodeOriginal->getChildGroup("L2CHILD1"); BOOST_CHECK(!(L2CHILD1NodeCopy == L2CHILD1NodeOriginal)); BOOST_CHECK_EQUAL(L2CHILD1NodeCopy->name(), L2CHILD1NodeOriginal->name()); - GroupTreeNodePtr L2CHILD2NodeCopy = L1CHILD1NodeCopy->getChildGroup("L2CHILD2"); - GroupTreeNodePtr L2CHILD2NodeOriginal = L1CHILD1NodeOriginal->getChildGroup("L2CHILD2"); + auto L2CHILD2NodeCopy = L1CHILD1NodeCopy->getChildGroup("L2CHILD2"); + auto L2CHILD2NodeOriginal = L1CHILD1NodeOriginal->getChildGroup("L2CHILD2"); BOOST_CHECK(!(L2CHILD2NodeCopy == L2CHILD2NodeOriginal)); BOOST_CHECK_EQUAL(L2CHILD2NodeCopy->name(), L2CHILD2NodeOriginal->name()); - GroupTreeNodePtr L3CHILD1NodeCopy = L2CHILD1NodeCopy->getChildGroup("L3CHILD1"); - GroupTreeNodePtr L3CHILD1NodeOriginal = L2CHILD1NodeOriginal->getChildGroup("L3CHILD1"); + auto L3CHILD1NodeCopy = L2CHILD1NodeCopy->getChildGroup("L3CHILD1"); + auto L3CHILD1NodeOriginal = L2CHILD1NodeOriginal->getChildGroup("L3CHILD1"); BOOST_CHECK(!(L3CHILD1NodeCopy == L3CHILD1NodeOriginal)); BOOST_CHECK_EQUAL(L3CHILD1NodeCopy->name(), L3CHILD1NodeOriginal->name()); } BOOST_AUTO_TEST_CASE(GetNodes_ReturnsAllNodes) { - GroupTreePtr tree(new GroupTree()); - tree->updateTree("L1CHILD1", "FIELD"); - tree->updateTree("L1CHILD2", "FIELD"); - tree->updateTree("L2CHILD1", "L1CHILD1"); - tree->updateTree("L2CHILD2", "L1CHILD1"); - tree->updateTree("L3CHILD1", "L2CHILD1"); + GroupTree tree; + tree.updateTree("L1CHILD1", "FIELD"); + tree.updateTree("L1CHILD2", "FIELD"); + tree.updateTree("L2CHILD1", "L1CHILD1"); + tree.updateTree("L2CHILD2", "L1CHILD1"); + tree.updateTree("L3CHILD1", "L2CHILD1"); - std::vector nodes = tree->getNodes(); + const auto& nodes = tree.getNodes(); BOOST_CHECK_EQUAL(6U, nodes.size()); BOOST_CHECK_EQUAL("FIELD", nodes[0U]->name()); BOOST_CHECK_EQUAL("L1CHILD1", nodes[1U]->name()); diff --git a/opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleTests.cpp b/opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleTests.cpp index 3708e5e27..9a7930346 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleTests.cpp +++ b/opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleTests.cpp @@ -266,9 +266,9 @@ BOOST_AUTO_TEST_CASE(CreateSchedule_DeckWithGRUPTREE_HasRootGroupTreeNodeForTime EclipseGrid grid(10,10,10); auto deck = deckWithGRUPTREE(); Schedule schedule(ParseContext() , grid , deck ); - GroupTreeNodePtr fieldNode = schedule.getGroupTree(0).getNode("FIELD"); + const auto& fieldNode = schedule.getGroupTree(0).getNode("FIELD"); BOOST_CHECK_EQUAL("FIELD", fieldNode->name()); - GroupTreeNodePtr FAREN = fieldNode->getChildGroup("FAREN"); + const auto& FAREN = fieldNode->getChildGroup("FAREN"); BOOST_CHECK(FAREN->hasChildGroup("BARNET")); } diff --git a/opm/parser/eclipse/Generator/KeywordGenerator.cpp b/opm/parser/eclipse/Generator/KeywordGenerator.cpp index b553a0a8e..30d424f6b 100644 --- a/opm/parser/eclipse/Generator/KeywordGenerator.cpp +++ b/opm/parser/eclipse/Generator/KeywordGenerator.cpp @@ -234,9 +234,9 @@ namespace Opm { stream << " ParserKeywords::" << keywordName << " inlineKeyword;" << std::endl; stream << " BOOST_CHECK( jsonKeyword.equal( inlineKeyword ));" << std::endl; stream << " if (jsonKeyword.hasDimension()) {" <size(); i++){ " << std::endl; - stream << " ParserItemConstPtr item = parserRecord->get( i );" << std::endl; + stream << " const auto& item = parserRecord->get( i );" << std::endl; stream << " for (size_t j=0; j < item->numDimensions(); j++) {" << std::endl; stream << " std::string dimString = item->getDimension(j);" << std::endl; stream << " BOOST_CHECK_NO_THROW( unitSystem.getNewDimension( dimString ));" << std::endl; diff --git a/opm/parser/eclipse/IntegrationTests/IntegrationTests.cpp b/opm/parser/eclipse/IntegrationTests/IntegrationTests.cpp index 454667071..27204a974 100644 --- a/opm/parser/eclipse/IntegrationTests/IntegrationTests.cpp +++ b/opm/parser/eclipse/IntegrationTests/IntegrationTests.cpp @@ -53,11 +53,11 @@ std::unique_ptr< ParserKeyword > createDynamicSized(const std::string& kw) { Parser createWWCTParser() { auto parserKeyword = createDynamicSized("WWCT"); - { - std::shared_ptr record = std::make_shared(); - record->addItem( ParserStringItemConstPtr(new ParserStringItem("WELL", ALL)) ); - parserKeyword->addRecord( record ); - } + + auto record = std::make_shared< ParserRecord >(); + record->addItem( std::make_shared< ParserStringItem >("WELL", ALL) ); + parserKeyword->addRecord( record ); + auto summaryKeyword = createFixedSized("SUMMARY" , (size_t) 0); Parser parser; @@ -141,9 +141,9 @@ static Parser createBPRParser() { auto parserKeyword = createDynamicSized("BPR"); { std::shared_ptr bprRecord = std::make_shared(); - bprRecord->addItem(ParserIntItemConstPtr(new ParserIntItem("I", SINGLE))); - bprRecord->addItem(ParserIntItemConstPtr(new ParserIntItem("J", SINGLE))); - bprRecord->addItem(ParserIntItemConstPtr(new ParserIntItem("K", SINGLE))); + bprRecord->addItem( std::make_shared< ParserIntItem >("I", SINGLE)); + bprRecord->addItem( std::make_shared< ParserIntItem >("J", SINGLE)); + bprRecord->addItem( std::make_shared< ParserIntItem >("K", SINGLE)); parserKeyword->addRecord( bprRecord ); } auto summaryKeyword = createFixedSized("SUMMARY" , (size_t) 0); @@ -229,9 +229,9 @@ BOOST_AUTO_TEST_CASE(parse_truncatedrecords_deckFilledWithDefaults) { BOOST_CHECK_EQUAL(lastItem_1.get< int >(0), 1); auto* parserKeyword = parser.getParserKeywordFromDeckName("RADFIN4"); - ParserRecordConstPtr parserRecord = parserKeyword->getRecord(0); - ParserItemConstPtr nwmaxItem = parserRecord->get("NWMAX"); - ParserIntItemConstPtr intItem = std::static_pointer_cast(nwmaxItem); + const auto& parserRecord = parserKeyword->getRecord(0); + const auto& nwmaxItem = parserRecord->get("NWMAX"); + auto intItem = std::static_pointer_cast(nwmaxItem); BOOST_CHECK_EQUAL(18, radfin4_0_full.getRecord(0).getItem(10).get< int >(0)); BOOST_CHECK_EQUAL(intItem->getDefault(), radfin4_1_partial.getRecord(0).getItem(10).get< int >(0)); diff --git a/opm/parser/eclipse/IntegrationTests/ScheduleCreateFromDeck.cpp b/opm/parser/eclipse/IntegrationTests/ScheduleCreateFromDeck.cpp index 1dadca1ae..9aabfe29a 100644 --- a/opm/parser/eclipse/IntegrationTests/ScheduleCreateFromDeck.cpp +++ b/opm/parser/eclipse/IntegrationTests/ScheduleCreateFromDeck.cpp @@ -47,9 +47,9 @@ BOOST_AUTO_TEST_CASE(CreateSchedule) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE1"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,10); - SchedulePtr sched(new Schedule(parseContext , grid , deck )); - const auto& timeMap = sched->getTimeMap(); - BOOST_CHECK_EQUAL(boost::posix_time::ptime(boost::gregorian::date(2007, boost::gregorian::May, 10)), sched->getStartTime()); + Schedule sched(parseContext , grid , deck ); + const auto& timeMap = sched.getTimeMap(); + BOOST_CHECK_EQUAL(boost::posix_time::ptime(boost::gregorian::date(2007, boost::gregorian::May, 10)), sched.getStartTime()); BOOST_CHECK_EQUAL(9U, timeMap.size()); BOOST_CHECK( deck.hasKeyword("NETBALAN") ); } @@ -61,9 +61,9 @@ BOOST_AUTO_TEST_CASE(CreateSchedule_Comments_After_Keywords) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_COMMENTS_AFTER_KEYWORDS"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,10); - SchedulePtr sched(new Schedule(parseContext , grid , deck )); - const auto& timeMap = sched->getTimeMap(); - BOOST_CHECK_EQUAL(boost::posix_time::ptime(boost::gregorian::date(2007, boost::gregorian::May, 10)), sched->getStartTime()); + Schedule sched(parseContext , grid , deck ); + const auto& timeMap = sched.getTimeMap(); + BOOST_CHECK_EQUAL(boost::posix_time::ptime(boost::gregorian::date(2007, boost::gregorian::May, 10)), sched.getStartTime()); BOOST_CHECK_EQUAL(9U, timeMap.size()); } @@ -74,7 +74,7 @@ BOOST_AUTO_TEST_CASE(WCONPROD_MissingCmode) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_MISSING_CMODE"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,3); - BOOST_CHECK_NO_THROW( new Schedule(parseContext , grid , deck ) ); + BOOST_CHECK_NO_THROW( Schedule(parseContext , grid , deck ) ); } @@ -85,7 +85,7 @@ BOOST_AUTO_TEST_CASE(WCONPROD_Missing_DATA) { auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,3); - BOOST_CHECK_THROW( new Schedule(parseContext , grid , deck ) , std::invalid_argument ); + BOOST_CHECK_THROW( Schedule(parseContext , grid , deck ) , std::invalid_argument ); } @@ -96,12 +96,12 @@ BOOST_AUTO_TEST_CASE(WellTestRefDepth) { auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(40,60,30); BOOST_CHECK_EQUAL(3, 3); - SchedulePtr sched(new Schedule(parseContext , grid , deck )); + Schedule sched(parseContext , grid , deck ); BOOST_CHECK_EQUAL(4, 4); - auto* well1 = sched->getWell("W_1"); - auto* well2 = sched->getWell("W_2"); - auto* well4 = sched->getWell("W_4"); + auto* well1 = sched.getWell("W_1"); + auto* well2 = sched.getWell("W_2"); + auto* well4 = sched.getWell("W_4"); BOOST_CHECK_EQUAL( well1->getRefDepth() , grid.getCellDepth( 29 , 36 , 0 )); BOOST_CHECK_EQUAL( well2->getRefDepth() , 100 ); BOOST_CHECK_THROW( well4->getRefDepth() , std::invalid_argument ); @@ -114,20 +114,20 @@ BOOST_AUTO_TEST_CASE(WellTestOpen) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WELLS2"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(40,60,30); - SchedulePtr sched(new Schedule(parseContext , grid , deck )); + Schedule sched(parseContext , grid , deck ); - auto well1 = sched->getWell( "W_1" ); - auto well2 = sched->getWell( "W_2" ); - auto well3 = sched->getWell( "W_3" ); + auto well1 = sched.getWell( "W_1" ); + auto well2 = sched.getWell( "W_2" ); + auto well3 = sched.getWell( "W_3" ); { - auto wells = sched->getOpenWells( 3 ); + auto wells = sched.getOpenWells( 3 ); BOOST_CHECK_EQUAL( 1U , wells.size() ); BOOST_CHECK_EQUAL( well1 , wells[0] ); } { - auto wells = sched->getOpenWells(6); + auto wells = sched.getOpenWells(6); BOOST_CHECK_EQUAL( 3U , wells.size() ); BOOST_CHECK_EQUAL( well1 , wells[0] ); @@ -136,7 +136,7 @@ BOOST_AUTO_TEST_CASE(WellTestOpen) { } { - auto wells = sched->getOpenWells(12); + auto wells = sched.getOpenWells(12); BOOST_CHECK_EQUAL( 2U , wells.size() ); BOOST_CHECK_EQUAL( well2 , wells[0] ); @@ -154,15 +154,15 @@ BOOST_AUTO_TEST_CASE(WellTesting) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WELLS2"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(40,60,30); - SchedulePtr sched(new Schedule(parseContext , grid , deck )); + Schedule sched(parseContext , grid , deck ); - BOOST_CHECK_EQUAL(4U, sched->numWells()); - BOOST_CHECK(sched->hasWell("W_1")); - BOOST_CHECK(sched->hasWell("W_2")); - BOOST_CHECK(sched->hasWell("W_3")); + BOOST_CHECK_EQUAL(4U, sched.numWells()); + BOOST_CHECK(sched.hasWell("W_1")); + BOOST_CHECK(sched.hasWell("W_2")); + BOOST_CHECK(sched.hasWell("W_3")); { - auto* well2 = sched->getWell("W_2"); + auto* well2 = sched.getWell("W_2"); BOOST_CHECK_EQUAL( 0 , well2->getProductionPropertiesCopy(2).ResVRate); BOOST_CHECK_CLOSE( 777/Metric::Time , well2->getProductionPropertiesCopy(7).ResVRate , 0.0001); BOOST_CHECK_EQUAL( 0 , well2->getProductionPropertiesCopy(8).ResVRate); @@ -182,7 +182,7 @@ BOOST_AUTO_TEST_CASE(WellTesting) { { - auto* well3 = sched->getWell("W_3"); + auto* well3 = sched.getWell("W_3"); BOOST_CHECK_EQUAL( WellCommon::AUTO , well3->getStatus(3)); BOOST_CHECK_EQUAL( 0 , well3->getProductionPropertiesCopy(2).LiquidRate); @@ -196,7 +196,7 @@ BOOST_AUTO_TEST_CASE(WellTesting) { } { - auto* well1 = sched->getWell("W_1"); + auto* well1 = sched.getWell("W_1"); BOOST_CHECK(well1->getProductionPropertiesCopy(0).predictionMode); BOOST_CHECK_EQUAL(0, well1->getProductionPropertiesCopy(0).OilRate); @@ -270,7 +270,7 @@ BOOST_AUTO_TEST_CASE(WellTestCOMPDAT_DEFAULTED_ITEMS) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_COMPDAT1"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(40,60,30); - SchedulePtr sched(new Schedule(parseContext , grid, deck)); + Schedule sched(parseContext , grid, deck); } @@ -280,14 +280,14 @@ BOOST_AUTO_TEST_CASE(WellTestCOMPDAT) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WELLS2"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(40,60,30); - SchedulePtr sched(new Schedule(parseContext , grid , deck)); + Schedule sched(parseContext , grid , deck); - BOOST_CHECK_EQUAL(4U, sched->numWells()); - BOOST_CHECK(sched->hasWell("W_1")); - BOOST_CHECK(sched->hasWell("W_2")); - BOOST_CHECK(sched->hasWell("W_3")); + BOOST_CHECK_EQUAL(4U, sched.numWells()); + BOOST_CHECK(sched.hasWell("W_1")); + BOOST_CHECK(sched.hasWell("W_2")); + BOOST_CHECK(sched.hasWell("W_3")); { - auto* well1 = sched->getWell("W_1"); + auto* well1 = sched.getWell("W_1"); BOOST_CHECK_CLOSE(13000/Metric::Time , well1->getProductionPropertiesCopy(8).OilRate , 0.0001); BOOST_CHECK_EQUAL(0U, well1->getCompletions( 0 ).size() ); @@ -310,26 +310,26 @@ BOOST_AUTO_TEST_CASE(GroupTreeTest_GRUPTREE_with_explicit_L0_parenting) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_GRUPTREE_EXPLICIT_PARENTING"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,3); - SchedulePtr sched(new Schedule(parseContext , grid , deck)); + Schedule sched(parseContext , grid , deck); - GroupTreeNodePtr rootNode = sched->getGroupTree(0).getNode("FIELD"); + const auto& rootNode = sched.getGroupTree(0).getNode("FIELD"); BOOST_REQUIRE_EQUAL("FIELD", rootNode->name()); BOOST_CHECK(rootNode->hasChildGroup("FIRST_LEVEL1")); - GroupTreeNodePtr FIRST_LEVEL1 = rootNode->getChildGroup("FIRST_LEVEL1"); + const auto& FIRST_LEVEL1 = rootNode->getChildGroup("FIRST_LEVEL1"); BOOST_CHECK(rootNode->hasChildGroup("FIRST_LEVEL2")); - GroupTreeNodePtr FIRST_LEVEL2 = rootNode->getChildGroup("FIRST_LEVEL2"); + const auto& FIRST_LEVEL2 = rootNode->getChildGroup("FIRST_LEVEL2"); BOOST_CHECK(FIRST_LEVEL1->hasChildGroup("SECOND_LEVEL1")); - GroupTreeNodePtr SECOND_LEVEL1 = FIRST_LEVEL1->getChildGroup("SECOND_LEVEL1"); + const auto& SECOND_LEVEL1 = FIRST_LEVEL1->getChildGroup("SECOND_LEVEL1"); BOOST_CHECK(FIRST_LEVEL2->hasChildGroup("SECOND_LEVEL2")); - GroupTreeNodePtr SECOND_LEVEL2 = FIRST_LEVEL2->getChildGroup("SECOND_LEVEL2"); + FIRST_LEVEL2->getChildGroup("SECOND_LEVEL2"); BOOST_CHECK(SECOND_LEVEL1->hasChildGroup("THIRD_LEVEL1")); - GroupTreeNodePtr THIRD_LEVEL1 = SECOND_LEVEL1->getChildGroup("THIRD_LEVEL1"); + SECOND_LEVEL1->getChildGroup("THIRD_LEVEL1"); } @@ -339,15 +339,15 @@ BOOST_AUTO_TEST_CASE(GroupTreeTest_GRUPTREE_correct) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WELSPECS_GRUPTREE"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,3); - SchedulePtr schedule(new Schedule(parseContext , grid , deck)); + Schedule schedule(parseContext , grid , deck); - BOOST_CHECK( schedule->hasGroup( "FIELD" )); - BOOST_CHECK( schedule->hasGroup( "PROD" )); - BOOST_CHECK( schedule->hasGroup( "INJE" )); - BOOST_CHECK( schedule->hasGroup( "MANI-PROD" )); - BOOST_CHECK( schedule->hasGroup( "MANI-INJ" )); - BOOST_CHECK( schedule->hasGroup( "DUMMY-PROD" )); - BOOST_CHECK( schedule->hasGroup( "DUMMY-INJ" )); + BOOST_CHECK( schedule.hasGroup( "FIELD" )); + BOOST_CHECK( schedule.hasGroup( "PROD" )); + BOOST_CHECK( schedule.hasGroup( "INJE" )); + BOOST_CHECK( schedule.hasGroup( "MANI-PROD" )); + BOOST_CHECK( schedule.hasGroup( "MANI-INJ" )); + BOOST_CHECK( schedule.hasGroup( "DUMMY-PROD" )); + BOOST_CHECK( schedule.hasGroup( "DUMMY-INJ" )); } @@ -358,25 +358,15 @@ BOOST_AUTO_TEST_CASE(GroupTreeTest_WELSPECS_AND_GRUPTREE_correct_iter_function) std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WELSPECS_GROUPS"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,3); - SchedulePtr schedule(new Schedule(parseContext , grid , deck)); + Schedule schedule(parseContext , grid , deck); // Time 0, only from WELSPECS - GroupTreeNodeConstPtr root = schedule->getGroupTree(0).getNode("FIELD"); + const auto& root0 = schedule.getGroupTree(0).getNode("FIELD"); + BOOST_CHECK_EQUAL( 2U, std::distance( root0->begin(), root0->end() ) ); - int iter_counted = 0; - - for (auto iter=root->begin(); iter != root->end(); ++iter) - iter_counted++; - - BOOST_CHECK_EQUAL(2, iter_counted); // Time 1, a new group added in tree - iter_counted = 0; - - root = schedule->getGroupTree(1).getNode("FIELD"); - for (auto iter=root->begin(); iter != root->end(); ++iter) { - iter_counted++; - } - BOOST_CHECK_EQUAL(3, iter_counted); + const auto& root1 = schedule.getGroupTree(1).getNode("FIELD"); + BOOST_CHECK_EQUAL( 3U, std::distance( root1->begin(), root1->end() ) ); } BOOST_AUTO_TEST_CASE(GroupTreeTest_WELSPECS_AND_GRUPTREE_correct_tree) { @@ -385,42 +375,42 @@ BOOST_AUTO_TEST_CASE(GroupTreeTest_WELSPECS_AND_GRUPTREE_correct_tree) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WELSPECS_GROUPS"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,3); - SchedulePtr schedule(new Schedule(parseContext , grid , deck)); + Schedule schedule(parseContext , grid , deck); // Time 0, only from WELSPECS - GroupTreeNodePtr root0 = schedule->getGroupTree(0).getNode("FIELD"); + const auto& root0 = schedule.getGroupTree(0).getNode("FIELD"); BOOST_REQUIRE_EQUAL("FIELD", root0->name()); BOOST_CHECK(root0->hasChildGroup("GROUP_BJARNE")); - GroupTreeNodePtr GROUP_BJARNE = root0->getChildGroup("GROUP_BJARNE"); + const auto& GROUP_BJARNE = root0->getChildGroup("GROUP_BJARNE"); BOOST_CHECK_EQUAL("GROUP_BJARNE", GROUP_BJARNE->name()); BOOST_CHECK(root0->hasChildGroup("GROUP_ODD")); - GroupTreeNodePtr GROUP_ODD = root0->getChildGroup("GROUP_ODD"); + const auto& GROUP_ODD = root0->getChildGroup("GROUP_ODD"); BOOST_CHECK_EQUAL("GROUP_ODD", GROUP_ODD->name()); // Time 1, now also from GRUPTREE - GroupTreeNodePtr root1 = schedule->getGroupTree(1).getNode("FIELD"); + const auto& root1 = schedule.getGroupTree(1).getNode("FIELD"); BOOST_REQUIRE_EQUAL("FIELD", root1->name()); BOOST_CHECK(root1->hasChildGroup("GROUP_BJARNE")); - GroupTreeNodePtr GROUP_BJARNE1 = root1->getChildGroup("GROUP_BJARNE"); + const auto& GROUP_BJARNE1 = root1->getChildGroup("GROUP_BJARNE"); BOOST_CHECK_EQUAL("GROUP_BJARNE", GROUP_BJARNE1->name()); BOOST_CHECK(root1->hasChildGroup("GROUP_ODD")); - GroupTreeNodePtr GROUP_ODD1 = root1->getChildGroup("GROUP_ODD"); + const auto& GROUP_ODD1 = root1->getChildGroup("GROUP_ODD"); BOOST_CHECK_EQUAL("GROUP_ODD", GROUP_ODD1->name()); // - from GRUPTREE BOOST_CHECK(GROUP_BJARNE1->hasChildGroup("GROUP_BIRGER")); - GroupTreeNodePtr GROUP_BIRGER = GROUP_BJARNE1->getChildGroup("GROUP_BIRGER"); + const auto& GROUP_BIRGER = GROUP_BJARNE1->getChildGroup("GROUP_BIRGER"); BOOST_CHECK_EQUAL("GROUP_BIRGER", GROUP_BIRGER->name()); BOOST_CHECK(root1->hasChildGroup("GROUP_NEW")); - GroupTreeNodePtr GROUP_NEW = root1->getChildGroup("GROUP_NEW"); + const auto& GROUP_NEW = root1->getChildGroup("GROUP_NEW"); BOOST_CHECK_EQUAL("GROUP_NEW", GROUP_NEW->name()); BOOST_CHECK(GROUP_NEW->hasChildGroup("GROUP_NILS")); - GroupTreeNodePtr GROUP_NILS = GROUP_NEW->getChildGroup("GROUP_NILS"); + const auto& GROUP_NILS = GROUP_NEW->getChildGroup("GROUP_NILS"); BOOST_CHECK_EQUAL("GROUP_NILS", GROUP_NILS->name()); } @@ -430,27 +420,27 @@ BOOST_AUTO_TEST_CASE(GroupTreeTest_GRUPTREE_WITH_REPARENT_correct_tree) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_GROUPS_REPARENT"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,3); - SchedulePtr schedule(new Schedule(parseContext , grid , deck)); + Schedule schedule(parseContext , grid , deck); // Time , from first GRUPTREE - GroupTreeNodePtr root0 = schedule->getGroupTree(0).getNode("FIELD"); + const auto& root0 = schedule.getGroupTree(0).getNode("FIELD"); BOOST_REQUIRE_EQUAL("FIELD", root0->name()); BOOST_CHECK(root0->hasChildGroup("GROUP_BJARNE")); - GroupTreeNodePtr GROUP_BJARNE0 = root0->getChildGroup("GROUP_BJARNE"); + const auto& GROUP_BJARNE0 = root0->getChildGroup("GROUP_BJARNE"); BOOST_CHECK_EQUAL("GROUP_BJARNE", GROUP_BJARNE0->name()); BOOST_CHECK(root0->hasChildGroup("GROUP_NEW")); - GroupTreeNodePtr GROUP_NEW0 = root0->getChildGroup("GROUP_NEW"); + const auto& GROUP_NEW0 = root0->getChildGroup("GROUP_NEW"); BOOST_CHECK_EQUAL("GROUP_NEW", GROUP_NEW0->name()); BOOST_CHECK(GROUP_BJARNE0->hasChildGroup("GROUP_BIRGER")); - GroupTreeNodePtr GROUP_BIRGER0 = GROUP_BJARNE0->getChildGroup("GROUP_BIRGER"); + const auto& GROUP_BIRGER0 = GROUP_BJARNE0->getChildGroup("GROUP_BIRGER"); BOOST_CHECK_EQUAL("GROUP_BIRGER", GROUP_BIRGER0->name()); BOOST_CHECK(GROUP_NEW0->hasChildGroup("GROUP_NILS")); - GroupTreeNodePtr GROUP_NILS0 = GROUP_NEW0->getChildGroup("GROUP_NILS"); + const auto& GROUP_NILS0 = GROUP_NEW0->getChildGroup("GROUP_NILS"); BOOST_CHECK_EQUAL("GROUP_NILS", GROUP_NILS0->name()); // SÅ den nye strukturen med et barneflytt @@ -463,9 +453,9 @@ BOOST_AUTO_TEST_CASE(GroupTreeTest_PrintGrouptree) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WELSPECS_GROUPS"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,3); - SchedulePtr sched(new Schedule(parseContext , grid , deck)); + Schedule sched(parseContext , grid , deck); - const auto& rootNode = sched->getGroupTree(0); + const auto& rootNode = sched.getGroupTree(0); rootNode.printTree(std::cout); } @@ -477,14 +467,14 @@ BOOST_AUTO_TEST_CASE( WellTestGroups ) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_GROUPS"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,3); - SchedulePtr sched( new Schedule(parseContext , grid , deck)); + Schedule sched(parseContext , grid , deck); - BOOST_CHECK_EQUAL( 3U , sched->numGroups() ); - BOOST_CHECK( sched->hasGroup( "INJ" )); - BOOST_CHECK( sched->hasGroup( "OP" )); + BOOST_CHECK_EQUAL( 3U , sched.numGroups() ); + BOOST_CHECK( sched.hasGroup( "INJ" )); + BOOST_CHECK( sched.hasGroup( "OP" )); { - auto& group = sched->getGroup("INJ"); + auto& group = sched.getGroup("INJ"); BOOST_CHECK_EQUAL( Phase::WATER , group.getInjectionPhase( 3 )); BOOST_CHECK_EQUAL( GroupInjection::VREP , group.getInjectionControlMode( 3 )); BOOST_CHECK_CLOSE( 10/Metric::Time , group.getSurfaceMaxRate( 3 ) , 0.001); @@ -500,7 +490,7 @@ BOOST_AUTO_TEST_CASE( WellTestGroups ) { } { - auto& group = sched->getGroup("OP"); + auto& group = sched.getGroup("OP"); BOOST_CHECK_EQUAL( GroupProduction::ORAT , group.getProductionControlMode(3)); BOOST_CHECK_CLOSE( 10/Metric::Time , group.getOilTargetRate(3) , 0.001); BOOST_CHECK_CLOSE( 20/Metric::Time , group.getWaterTargetRate(3) , 0.001); @@ -519,10 +509,10 @@ BOOST_AUTO_TEST_CASE( WellTestGroupAndWellRelation ) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WELLS_AND_GROUPS"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,3); - SchedulePtr sched( new Schedule(parseContext , grid , deck)); + Schedule sched(parseContext , grid , deck); - auto& group1 = sched->getGroup("GROUP1"); - auto& group2 = sched->getGroup("GROUP2"); + auto& group1 = sched.getGroup("GROUP1"); + auto& group2 = sched.getGroup("GROUP2"); BOOST_CHECK( group1.hasBeenDefined(0) ); BOOST_CHECK( !group2.hasBeenDefined(0)); @@ -546,26 +536,26 @@ BOOST_AUTO_TEST_CASE(WellTestWELSPECSDataLoaded) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WELLS2"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(40,60,30); - SchedulePtr sched(new Schedule(parseContext , grid , deck)); + Schedule sched(parseContext , grid , deck); - BOOST_CHECK_EQUAL(4U, sched->numWells()); - BOOST_CHECK(sched->hasWell("W_1")); - BOOST_CHECK(sched->hasWell("W_2")); - BOOST_CHECK(sched->hasWell("W_3")); + BOOST_CHECK_EQUAL(4U, sched.numWells()); + BOOST_CHECK(sched.hasWell("W_1")); + BOOST_CHECK(sched.hasWell("W_2")); + BOOST_CHECK(sched.hasWell("W_3")); { - const auto* well1 = sched->getWell("W_1"); + const auto* well1 = sched.getWell("W_1"); BOOST_CHECK(!well1->hasBeenDefined(2)); BOOST_CHECK(well1->hasBeenDefined(3)); BOOST_CHECK_EQUAL(29, well1->getHeadI()); BOOST_CHECK_EQUAL(36, well1->getHeadJ()); - const auto* well2 = sched->getWell("W_2"); + const auto* well2 = sched.getWell("W_2"); BOOST_CHECK(!well2->hasBeenDefined(2)); BOOST_CHECK(well2->hasBeenDefined(3)); BOOST_CHECK_EQUAL(19, well2->getHeadI()); BOOST_CHECK_EQUAL(50, well2->getHeadJ()); - const auto* well3 = sched->getWell("W_3"); + const auto* well3 = sched.getWell("W_3"); BOOST_CHECK(!well3->hasBeenDefined(2)); BOOST_CHECK(well3->hasBeenDefined(3)); BOOST_CHECK_EQUAL(30, well3->getHeadI()); @@ -579,7 +569,7 @@ BOOST_AUTO_TEST_CASE(WellTestWELSPECS_InvalidConfig_Throws) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WELL_INVALID_WELSPECS"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,3); - BOOST_CHECK_THROW(new Schedule(parseContext , grid , deck), std::invalid_argument); + BOOST_CHECK_THROW(Schedule(parseContext , grid , deck), std::invalid_argument); } @@ -589,7 +579,7 @@ BOOST_AUTO_TEST_CASE(WellTestWELOPEN_ConfigWithIndexes_Throws) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WELOPEN_INVALID"); auto deck = parser.parseFile(scheduleFile); std::shared_ptr grid = std::make_shared(10,10,3); - BOOST_CHECK_THROW(new Schedule(grid , deck), std::logic_error); + BOOST_CHECK_THROW(Schedule(grid , deck), std::logic_error); } @@ -598,15 +588,15 @@ BOOST_AUTO_TEST_CASE(WellTestWELOPENControlsSet) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WELOPEN"); auto deck = parser.parseFile(scheduleFile); std::shared_ptr grid = std::make_shared( 10,10,10 ); - SchedulePtr sched(new Schedule(grid , deck)); + Schedule sched(grid , deck); - const auto* well1 = sched->getWell("W_1"); - BOOST_CHECK_EQUAL(WellCommon::StatusEnum::OPEN, sched->getWell("W_1")->getStatus(0)); - BOOST_CHECK_EQUAL(WellCommon::StatusEnum::SHUT, sched->getWell("W_1")->getStatus(1)); - BOOST_CHECK_EQUAL(WellCommon::StatusEnum::OPEN, sched->getWell("W_1")->getStatus(2)); - BOOST_CHECK_EQUAL(WellCommon::StatusEnum::STOP, sched->getWell("W_1")->getStatus(3)); - BOOST_CHECK_EQUAL(WellCommon::StatusEnum::AUTO, sched->getWell("W_1")->getStatus(4)); - BOOST_CHECK_EQUAL(WellCommon::StatusEnum::STOP, sched->getWell("W_1")->getStatus(5)); + const auto* well1 = sched.getWell("W_1"); + BOOST_CHECK_EQUAL(WellCommon::StatusEnum::OPEN, sched.getWell("W_1")->getStatus(0)); + BOOST_CHECK_EQUAL(WellCommon::StatusEnum::SHUT, sched.getWell("W_1")->getStatus(1)); + BOOST_CHECK_EQUAL(WellCommon::StatusEnum::OPEN, sched.getWell("W_1")->getStatus(2)); + BOOST_CHECK_EQUAL(WellCommon::StatusEnum::STOP, sched.getWell("W_1")->getStatus(3)); + BOOST_CHECK_EQUAL(WellCommon::StatusEnum::AUTO, sched.getWell("W_1")->getStatus(4)); + BOOST_CHECK_EQUAL(WellCommon::StatusEnum::STOP, sched.getWell("W_1")->getStatus(5)); } */ @@ -618,21 +608,21 @@ BOOST_AUTO_TEST_CASE(WellTestWGRUPCONWellPropertiesSet) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WGRUPCON"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,10); - SchedulePtr sched(new Schedule(parseContext , grid , deck)); + Schedule sched(parseContext , grid , deck); - const auto* well1 = sched->getWell("W_1"); + const auto* well1 = sched.getWell("W_1"); BOOST_CHECK(well1->isAvailableForGroupControl(0)); BOOST_CHECK_EQUAL(-1, well1->getGuideRate(0)); BOOST_CHECK_EQUAL(GuideRate::OIL, well1->getGuideRatePhase(0)); BOOST_CHECK_EQUAL(1.0, well1->getGuideRateScalingFactor(0)); - const auto* well2 = sched->getWell("W_2"); + const auto* well2 = sched.getWell("W_2"); BOOST_CHECK(!well2->isAvailableForGroupControl(0)); BOOST_CHECK_EQUAL(-1, well2->getGuideRate(0)); BOOST_CHECK_EQUAL(GuideRate::UNDEFINED, well2->getGuideRatePhase(0)); BOOST_CHECK_EQUAL(1.0, well2->getGuideRateScalingFactor(0)); - const auto* well3 = sched->getWell("W_3"); + const auto* well3 = sched.getWell("W_3"); BOOST_CHECK(well3->isAvailableForGroupControl(0)); BOOST_CHECK_EQUAL(100, well3->getGuideRate(0)); BOOST_CHECK_EQUAL(GuideRate::RAT, well3->getGuideRatePhase(0)); @@ -657,8 +647,8 @@ COMPDAT \n\ /\n"; auto deck = parser.parseString(deckString, parseContext); EclipseGrid grid(30,30,10); - SchedulePtr sched(new Schedule(parseContext , grid , deck)); - const auto* well = sched->getWell("W1"); + Schedule sched(parseContext , grid , deck); + const auto* well = sched.getWell("W1"); const auto& completions = well->getCompletions(0); BOOST_CHECK_EQUAL( 10 , completions.get(0).getI() ); BOOST_CHECK_EQUAL( 20 , completions.get(0).getJ() ); @@ -675,7 +665,7 @@ BOOST_AUTO_TEST_CASE(OpmCode) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/wells_group.data"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(10,10,3); - BOOST_CHECK_NO_THROW( new Schedule(parseContext , grid , deck) ); + BOOST_CHECK_NO_THROW( Schedule(parseContext , grid , deck) ); } @@ -686,12 +676,12 @@ BOOST_AUTO_TEST_CASE(WELLS_SHUT) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_SHUT_WELL"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(20,40,1); - SchedulePtr sched(new Schedule(parseContext , grid , deck)); + Schedule sched(parseContext , grid , deck); - const auto* well1 = sched->getWell("W1"); - const auto* well2 = sched->getWell("W2"); - const auto* well3 = sched->getWell("W3"); + const auto* well1 = sched.getWell("W1"); + const auto* well2 = sched.getWell("W2"); + const auto* well3 = sched.getWell("W3"); BOOST_CHECK_EQUAL( WellCommon::StatusEnum::OPEN , well1->getStatus(1)); BOOST_CHECK_EQUAL( WellCommon::StatusEnum::OPEN , well2->getStatus(1)); @@ -710,14 +700,14 @@ BOOST_AUTO_TEST_CASE(WellTestWPOLYMER) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_POLYMER"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(30,30,30); - SchedulePtr sched(new Schedule(parseContext , grid , deck)); + Schedule sched(parseContext , grid , deck); - BOOST_CHECK_EQUAL(4U, sched->numWells()); - BOOST_CHECK(sched->hasWell("INJE01")); - BOOST_CHECK(sched->hasWell("PROD01")); + BOOST_CHECK_EQUAL(4U, sched.numWells()); + BOOST_CHECK(sched.hasWell("INJE01")); + BOOST_CHECK(sched.hasWell("PROD01")); - const auto* well1 = sched->getWell("INJE01"); + const auto* well1 = sched.getWell("INJE01"); BOOST_CHECK( well1->isInjector(0)); { const WellPolymerProperties& props_well10 = well1->getPolymerProperties(0); @@ -728,7 +718,7 @@ BOOST_AUTO_TEST_CASE(WellTestWPOLYMER) { BOOST_CHECK_CLOSE(0.1*Metric::PolymerDensity, props_well12.m_polymerConcentration, 0.0001); } - const auto* well2 = sched->getWell("INJE02"); + const auto* well2 = sched.getWell("INJE02"); BOOST_CHECK( well2->isInjector(0)); { const WellPolymerProperties& props_well20 = well2->getPolymerProperties(0); @@ -739,7 +729,7 @@ BOOST_AUTO_TEST_CASE(WellTestWPOLYMER) { BOOST_CHECK_CLOSE(0.2*Metric::PolymerDensity, props_well22.m_polymerConcentration, 0.0001); } - const auto* well3 = sched->getWell("INJE03"); + const auto* well3 = sched.getWell("INJE03"); BOOST_CHECK( well3->isInjector(0)); { const WellPolymerProperties& props_well30 = well3->getPolymerProperties(0); @@ -758,14 +748,14 @@ BOOST_AUTO_TEST_CASE(WellTestWECON) { std::string scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WECON"); auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(30,30,30); - SchedulePtr sched(new Schedule(parseContext , grid , deck)); + Schedule sched(parseContext , grid , deck); - BOOST_CHECK_EQUAL(3U, sched->numWells()); - BOOST_CHECK(sched->hasWell("INJE01")); - BOOST_CHECK(sched->hasWell("PROD01")); - BOOST_CHECK(sched->hasWell("PROD02")); + BOOST_CHECK_EQUAL(3U, sched.numWells()); + BOOST_CHECK(sched.hasWell("INJE01")); + BOOST_CHECK(sched.hasWell("PROD01")); + BOOST_CHECK(sched.hasWell("PROD02")); - const auto* prod1 = sched->getWell("PROD01"); + const auto* prod1 = sched.getWell("PROD01"); { const WellEconProductionLimits& econ_limit1 = prod1->getEconProductionLimits(0); BOOST_CHECK(econ_limit1.onMinOilRate()); @@ -812,7 +802,7 @@ BOOST_AUTO_TEST_CASE(WellTestWECON) { BOOST_CHECK(econ_limit2.onAnyEffectiveLimit()); } - const auto* prod2 = sched->getWell("PROD02"); + const auto* prod2 = sched.getWell("PROD02"); { const WellEconProductionLimits& econ_limit1 = prod2->getEconProductionLimits(0); BOOST_CHECK(!(econ_limit1.onMinOilRate())); @@ -868,8 +858,8 @@ BOOST_AUTO_TEST_CASE(TestEvents) { auto deck = parser.parseFile(scheduleFile, parseContext); EclipseGrid grid(40,40,30); - SchedulePtr sched(new Schedule(parseContext , grid , deck)); - const Events& events = sched->getEvents(); + Schedule sched(parseContext , grid , deck); + const Events& events = sched.getEvents(); BOOST_CHECK( events.hasEvent(ScheduleEvents::NEW_WELL , 0 ) ); BOOST_CHECK( !events.hasEvent(ScheduleEvents::NEW_WELL , 1 ) ); diff --git a/opm/parser/eclipse/Parser/Parser.cpp b/opm/parser/eclipse/Parser/Parser.cpp index 74a39a0f0..f2fd704ce 100644 --- a/opm/parser/eclipse/Parser/Parser.cpp +++ b/opm/parser/eclipse/Parser/Parser.cpp @@ -226,7 +226,7 @@ class ParserState { boost::filesystem::path rootPath; public: - RawKeywordPtr rawKeyword; + std::shared_ptr< RawKeyword > rawKeyword; string_view nextKeyword = emptystr; Deck deck; const ParseContext& parseContext; @@ -758,7 +758,6 @@ std::vector Parser::getAllDeckNames () const { try { Json::JsonObject jsonKeyword(configFile); - ParserKeywordConstPtr parserKeyword = std::make_shared(jsonKeyword); addParserKeyword( std::unique_ptr< ParserKeyword >( new ParserKeyword( jsonKeyword ) ) ); return true; } diff --git a/opm/parser/eclipse/Parser/ParserDoubleItem.hpp b/opm/parser/eclipse/Parser/ParserDoubleItem.hpp index 25b4a4377..b520e1db2 100644 --- a/opm/parser/eclipse/Parser/ParserDoubleItem.hpp +++ b/opm/parser/eclipse/Parser/ParserDoubleItem.hpp @@ -63,9 +63,6 @@ namespace Opm { double m_default; std::vector m_dimensions; }; - - typedef std::shared_ptr ParserDoubleItemConstPtr; - typedef std::shared_ptr ParserDoubleItemPtr; } #endif /* PARSERINTITEM_HPP */ diff --git a/opm/parser/eclipse/Parser/ParserIntItem.hpp b/opm/parser/eclipse/Parser/ParserIntItem.hpp index 076abbcb1..c2a85e3dc 100644 --- a/opm/parser/eclipse/Parser/ParserIntItem.hpp +++ b/opm/parser/eclipse/Parser/ParserIntItem.hpp @@ -56,9 +56,6 @@ namespace Opm { private: int m_default; }; - - typedef std::shared_ptr< ParserIntItem > ParserIntItemPtr; - typedef std::shared_ptr< const ParserIntItem > ParserIntItemConstPtr; } #endif /* PARSERINTITEM_HPP */ diff --git a/opm/parser/eclipse/Parser/ParserItem.hpp b/opm/parser/eclipse/Parser/ParserItem.hpp index d2a5f094e..8cd6f9b21 100644 --- a/opm/parser/eclipse/Parser/ParserItem.hpp +++ b/opm/parser/eclipse/Parser/ParserItem.hpp @@ -100,10 +100,6 @@ namespace Opm { std::string m_description; }; - typedef std::shared_ptr ParserItemPtr; - typedef std::shared_ptr ParserItemConstPtr; - - template void ParserItemInlineClassDeclaration(const ParserItemType * self , std::ostream& os, const std::string& indent , const std::string& typeString) { diff --git a/opm/parser/eclipse/Parser/ParserKeyword.cpp b/opm/parser/eclipse/Parser/ParserKeyword.cpp index cfa07079d..da32c54fc 100644 --- a/opm/parser/eclipse/Parser/ParserKeyword.cpp +++ b/opm/parser/eclipse/Parser/ParserKeyword.cpp @@ -313,20 +313,18 @@ namespace Opm { switch (valueType) { case INT: { - ParserIntItemConstPtr item = ParserIntItemConstPtr(new ParserIntItem(itemConfig)); - record->addItem( item ); + record->addItem( std::make_shared< ParserIntItem >( itemConfig ) ); } break; case STRING: { - ParserStringItemConstPtr item = ParserStringItemConstPtr(new ParserStringItem(itemConfig)); - record->addItem(item); + record->addItem( std::make_shared< ParserStringItem >( itemConfig ) ); } break; case DOUBLE: { - ParserDoubleItemPtr item = ParserDoubleItemPtr(new ParserDoubleItem(itemConfig)); - initDoubleItemDimension( item , itemConfig ); + auto item = std::make_shared< ParserDoubleItem >( itemConfig ); + initDoubleItemDimension( item, itemConfig ); record->addItem(item); } break; @@ -341,7 +339,7 @@ namespace Opm { throw std::invalid_argument("The 'items' JSON item missing must be an array in keyword "+getName()+"."); } - void ParserKeyword::initDoubleItemDimension( ParserDoubleItemPtr item, const Json::JsonObject itemConfig) { + void ParserKeyword::initDoubleItemDimension( std::shared_ptr< ParserDoubleItem > item, const Json::JsonObject itemConfig) { if (itemConfig.has_item("dimension")) { const Json::JsonObject dimensionConfig = itemConfig.get_item("dimension"); if (dimensionConfig.is_string()) @@ -372,7 +370,7 @@ namespace Opm { switch (valueType) { case INT: { - ParserIntItemPtr item = ParserIntItemPtr(new ParserIntItem(itemName, ALL)); + auto item = std::make_shared< ParserIntItem >( itemName, ALL ); if (hasDefault) { int defaultValue = dataConfig.get_int("default"); item->setDefault(defaultValue); @@ -382,7 +380,7 @@ namespace Opm { break; case STRING: { - ParserStringItemPtr item = ParserStringItemPtr(new ParserStringItem(itemName, ALL)); + auto item = std::make_shared< ParserStringItem >(itemName, ALL); if (hasDefault) { std::string defaultValue = dataConfig.get_string("default"); item->setDefault(defaultValue); @@ -392,7 +390,7 @@ namespace Opm { break; case DOUBLE: { - ParserDoubleItemPtr item = ParserDoubleItemPtr(new ParserDoubleItem(itemName, ALL)); + auto item = std::make_shared< ParserDoubleItem >(itemName, ALL); if (hasDefault) { double defaultValue = dataConfig.get_double("default"); item->setDefault(defaultValue); @@ -409,16 +407,16 @@ namespace Opm { throw std::invalid_argument("The 'value_type' JSON item of keyword "+getName()+" is missing"); } - ParserRecordPtr ParserKeyword::getRecord(size_t recordIndex) const { + std::shared_ptr< ParserRecord > ParserKeyword::getRecord(size_t recordIndex) const { return m_records.get( recordIndex ); } - std::vector::const_iterator ParserKeyword::recordBegin() const { + std::vector >::const_iterator ParserKeyword::recordBegin() const { return m_records.begin(); } - std::vector::const_iterator ParserKeyword::recordEnd() const { + std::vector >::const_iterator ParserKeyword::recordEnd() const { return m_records.end(); } @@ -473,7 +471,9 @@ namespace Opm { return m_deckNames.end(); } - DeckKeyword ParserKeyword::parse(const ParseContext& parseContext , MessageContainer& msgContainer, RawKeywordPtr rawKeyword) const { + DeckKeyword ParserKeyword::parse(const ParseContext& parseContext, + MessageContainer& msgContainer, + std::shared_ptr< RawKeyword > rawKeyword) const { if( !rawKeyword->isFinished() ) throw std::invalid_argument("Tried to create a deck keyword from an incomplete raw keyword " + rawKeyword->getKeywordName()); @@ -602,7 +602,7 @@ namespace Opm { for (auto iter = recordBegin(); iter != recordEnd(); ++iter) { std::shared_ptr record = *iter; for (size_t i = 0; i < record->size(); i++) { - ParserItemConstPtr item = record->get(i); + const auto& item = record->get(i); ss << std::endl; item->inlineClass(ss , local_indent ); } @@ -678,11 +678,11 @@ namespace Opm { ss << indent << "{" << std::endl; ss << local_indent << "std::shared_ptr record = std::make_shared();" << std::endl; for (size_t i = 0; i < record->size(); i++) { - ParserItemConstPtr item = record->get(i); + const auto& item = record->get(i); ss << local_indent << "{" << std::endl; { std::string indent3 = local_indent + " "; - ss << indent3 << "ParserItemPtr item(" << item->createCode() << ");" << std::endl; + ss << indent3 << "std::shared_ptr< ParserItem > item(" << item->createCode() << ");" << std::endl; ss << indent3 << "item->setDescription(\"" << item->getDescription() << "\");" << std::endl; for (size_t idim=0; idim < item->numDimensions(); idim++) ss << indent3 <<"item->push_backDimension(\"" << item->getDimension( idim ) << "\");" << std::endl; @@ -712,7 +712,7 @@ namespace Opm { for (auto iter = recordBegin(); iter != recordEnd(); ++iter) { std::shared_ptr record = *iter; for (size_t i = 0; i < record->size(); i++) { - ParserItemConstPtr item = record->get(i); + const auto& item = record->get(i); ss << item->inlineClassInit(className()); } } diff --git a/opm/parser/eclipse/Parser/ParserKeyword.hpp b/opm/parser/eclipse/Parser/ParserKeyword.hpp index 09660f877..e0eeb64f4 100644 --- a/opm/parser/eclipse/Parser/ParserKeyword.hpp +++ b/opm/parser/eclipse/Parser/ParserKeyword.hpp @@ -127,10 +127,6 @@ namespace Opm { void addItems( const Json::JsonObject& jsonConfig); void initDoubleItemDimension( std::shared_ptr< ParserDoubleItem > item, const Json::JsonObject itemConfig); }; - - typedef std::shared_ptr ParserKeywordPtr; - typedef std::shared_ptr ParserKeywordConstPtr; - } #endif diff --git a/opm/parser/eclipse/Parser/ParserRecord.cpp b/opm/parser/eclipse/Parser/ParserRecord.cpp index f693a527a..4fbc6ec88 100644 --- a/opm/parser/eclipse/Parser/ParserRecord.cpp +++ b/opm/parser/eclipse/Parser/ParserRecord.cpp @@ -36,7 +36,7 @@ namespace Opm { return m_items.size(); } - void ParserRecord::addItem(ParserItemConstPtr item) { + void ParserRecord::addItem(std::shared_ptr< const ParserItem > item) { if (m_dataRecord) throw std::invalid_argument("Record is already marked as DataRecord - can not add items"); @@ -47,7 +47,7 @@ namespace Opm { throw std::invalid_argument("Itemname: " + item->name() + " already exists."); } - void ParserRecord::addDataItem(ParserItemConstPtr item) { + void ParserRecord::addDataItem(std::shared_ptr< const ParserItem > item) { if (m_items.size() > 0) throw std::invalid_argument("Record already contains items - can not add Data Item"); @@ -57,12 +57,12 @@ namespace Opm { - std::vector::const_iterator ParserRecord::begin() const { + std::vector< std::shared_ptr< const ParserItem > >::const_iterator ParserRecord::begin() const { return m_items.begin(); } - std::vector::const_iterator ParserRecord::end() const { + std::vector< std::shared_ptr< const ParserItem > >::const_iterator ParserRecord::end() const { return m_items.end(); } @@ -94,7 +94,7 @@ namespace Opm { } - ParserItemConstPtr ParserRecord::get(size_t index) const { + std::shared_ptr< const ParserItem > ParserRecord::get(size_t index) const { if (index < m_items.size()) return m_items[ index ]; else @@ -108,13 +108,8 @@ namespace Opm { return true; } - ParserItemConstPtr ParserRecord::get(const std::string& itemName) const { - if (m_itemMap.find(itemName) == m_itemMap.end()) - throw std::invalid_argument("Itemname: " + itemName + " does not exist."); - else { - std::map::const_iterator theItem = m_itemMap.find(itemName); - return (*theItem).second; - } + std::shared_ptr< const ParserItem > ParserRecord::get(const std::string& itemName) const { + return this->m_itemMap.at( itemName ); } DeckRecord ParserRecord::parse(const ParseContext& parseContext , MessageContainer& msgContainer, RawRecord& rawRecord ) const { @@ -141,8 +136,8 @@ namespace Opm { if (itemIndex == size()) break; { - ParserItemConstPtr item = get(itemIndex); - ParserItemConstPtr otherItem = other.get(itemIndex); + const auto& item = get(itemIndex); + const auto& otherItem = other.get(itemIndex); if (!item->equal(*otherItem)) { equal_ = false; diff --git a/opm/parser/eclipse/Parser/ParserRecord.hpp b/opm/parser/eclipse/Parser/ParserRecord.hpp index cc21975cd..872e0f4f4 100644 --- a/opm/parser/eclipse/Parser/ParserRecord.hpp +++ b/opm/parser/eclipse/Parser/ParserRecord.hpp @@ -54,9 +54,6 @@ namespace Opm { std::vector> m_items; std::map> m_itemMap; }; - - typedef std::shared_ptr ParserRecordConstPtr; - typedef std::shared_ptr ParserRecordPtr; } diff --git a/opm/parser/eclipse/Parser/ParserStringItem.hpp b/opm/parser/eclipse/Parser/ParserStringItem.hpp index 4cab9057f..fa59bd0b4 100644 --- a/opm/parser/eclipse/Parser/ParserStringItem.hpp +++ b/opm/parser/eclipse/Parser/ParserStringItem.hpp @@ -53,9 +53,6 @@ namespace Opm { private: std::string m_default; }; - - typedef std::shared_ptr ParserStringItemConstPtr; - typedef std::shared_ptr ParserStringItemPtr; } #endif /* PARSERSTRINGITEM_HPP */ diff --git a/opm/parser/eclipse/Parser/tests/ParserItemTests.cpp b/opm/parser/eclipse/Parser/tests/ParserItemTests.cpp index cbb81a68b..01f8aeeea 100644 --- a/opm/parser/eclipse/Parser/tests/ParserItemTests.cpp +++ b/opm/parser/eclipse/Parser/tests/ParserItemTests.cpp @@ -596,8 +596,8 @@ BOOST_AUTO_TEST_CASE(scan_intsAndStrings_dataCorrect) { BOOST_AUTO_TEST_CASE(ParserItemCheckEqualsOverride) { - ParserItemConstPtr itemDefault10( new ParserIntItem("ITEM" , 10) ); - ParserItemConstPtr itemDefault20( new ParserIntItem("ITEM" , 20) ); + auto itemDefault10 = std::make_shared< ParserIntItem >( "ITEM" , 10 ); + auto itemDefault20 = std::make_shared< ParserIntItem >( "ITEM" , 20 ); BOOST_CHECK( itemDefault10->equal( *itemDefault10 )); BOOST_CHECK_EQUAL( false , itemDefault10->equal( *itemDefault20 )); diff --git a/opm/parser/eclipse/Parser/tests/ParserKeywordTests.cpp b/opm/parser/eclipse/Parser/tests/ParserKeywordTests.cpp index 2ba100e9f..e93baeb2a 100644 --- a/opm/parser/eclipse/Parser/tests/ParserKeywordTests.cpp +++ b/opm/parser/eclipse/Parser/tests/ParserKeywordTests.cpp @@ -66,32 +66,32 @@ std::shared_ptr createTable(const std::string& name, } BOOST_AUTO_TEST_CASE(construct_withname_nameSet) { - ParserKeywordConstPtr parserKeyword = createDynamicSized("BPR"); + const auto& parserKeyword = createDynamicSized("BPR"); BOOST_CHECK_EQUAL(parserKeyword->getName(), "BPR"); } BOOST_AUTO_TEST_CASE(NamedInit) { std::string keyword("KEYWORD"); - ParserKeywordConstPtr parserKeyword = createFixedSized(keyword, (size_t) 100); + const auto& parserKeyword = createFixedSized(keyword, (size_t) 100); BOOST_CHECK_EQUAL(parserKeyword->getName(), keyword); } BOOST_AUTO_TEST_CASE(ParserKeyword_default_SizeTypedefault) { std::string keyword("KEYWORD"); - ParserKeywordConstPtr parserKeyword = createDynamicSized(keyword); + const auto& parserKeyword = createDynamicSized(keyword); BOOST_CHECK_EQUAL(parserKeyword->getSizeType() , SLASH_TERMINATED); } BOOST_AUTO_TEST_CASE(ParserKeyword_withSize_SizeTypeFIXED) { std::string keyword("KEYWORD"); - ParserKeywordConstPtr parserKeyword = createFixedSized(keyword, (size_t) 100); + const auto& parserKeyword = createFixedSized(keyword, (size_t) 100); BOOST_CHECK_EQUAL(parserKeyword->getSizeType() , FIXED); } BOOST_AUTO_TEST_CASE(ParserKeyword_withOtherSize_SizeTypeOTHER) { std::string keyword("KEYWORD"); - ParserKeywordConstPtr parserKeyword = createTable(keyword, "EQUILDIMS" , "NTEQUIL" , false); + const auto& parserKeyword = createTable(keyword, "EQUILDIMS" , "NTEQUIL" , false); const std::pair& sizeKW = parserKeyword->getSizeDefinitionPair(); BOOST_CHECK_EQUAL(OTHER_KEYWORD_IN_DECK , parserKeyword->getSizeType() ); BOOST_CHECK_EQUAL("EQUILDIMS", sizeKW.first ); @@ -135,7 +135,7 @@ BOOST_AUTO_TEST_CASE(ParserKeyword_validInternalName) { } BOOST_AUTO_TEST_CASE(ParserKeywordMatches) { - ParserKeywordPtr parserKeyword = createFixedSized("HELLO", (size_t) 1); + const auto& parserKeyword = createFixedSized("HELLO", (size_t) 1); parserKeyword->clearDeckNames(); parserKeyword->setMatchRegex("WORLD.+"); BOOST_CHECK_EQUAL( false , parserKeyword->matches("HELLO")); @@ -146,8 +146,8 @@ BOOST_AUTO_TEST_CASE(ParserKeywordMatches) { } BOOST_AUTO_TEST_CASE(AddDataKeyword_correctlyConfigured) { - ParserKeywordPtr parserKeyword = createFixedSized("PORO", (size_t) 1); - ParserIntItemConstPtr item = ParserIntItemConstPtr(new ParserIntItem( "ACTNUM" , ALL)); + const auto& parserKeyword = createFixedSized("PORO", (size_t) 1); + const auto& item = std::make_shared< ParserIntItem >( "ACTNUM" , ALL); std::shared_ptr record = std::make_shared(); BOOST_CHECK_EQUAL( false , parserKeyword->isDataKeyword() ); @@ -160,8 +160,8 @@ BOOST_AUTO_TEST_CASE(AddDataKeyword_correctlyConfigured) { } BOOST_AUTO_TEST_CASE(WrongConstructor_addDataItem_throws) { - ParserKeywordPtr parserKeyword = createDynamicSized("PORO"); - ParserIntItemConstPtr dataItem = ParserIntItemConstPtr(new ParserIntItem( "ACTNUM" , ALL )); + const auto& parserKeyword = createDynamicSized("PORO"); + const auto& dataItem = std::make_shared< ParserIntItem >( "ACTNUM" , ALL ); std::shared_ptr record = std::make_shared(); record->addDataItem( dataItem ); BOOST_CHECK_THROW( parserKeyword->addDataRecord( record ) , std::invalid_argument); @@ -169,7 +169,7 @@ BOOST_AUTO_TEST_CASE(WrongConstructor_addDataItem_throws) { BOOST_AUTO_TEST_CASE(DefaultConstructur_setDescription_canReadBack) { - ParserKeywordPtr parserKeyword = createDynamicSized("BPR"); + const auto& parserKeyword = createDynamicSized("BPR"); std::string description("This is the description"); parserKeyword->setDescription(description); BOOST_CHECK_EQUAL( description, parserKeyword->getDescription()); @@ -179,7 +179,7 @@ BOOST_AUTO_TEST_CASE(DefaultConstructur_setDescription_canReadBack) { /* json */ BOOST_AUTO_TEST_CASE(ConstructFromJsonObject) { Json::JsonObject jsonObject("{\"name\": \"XXX\", \"sections\":[], \"size\" : 0}"); - ParserKeywordConstPtr parserKeyword = std::make_shared(jsonObject); + const auto& parserKeyword = std::make_shared(jsonObject); BOOST_CHECK_EQUAL("XXX" , parserKeyword->getName()); BOOST_CHECK_EQUAL( true , parserKeyword->hasFixedSize() ); } @@ -210,7 +210,7 @@ BOOST_AUTO_TEST_CASE(ConstructMultiNameFromJsonObject) { BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withSize) { Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}"); - ParserKeywordConstPtr parserKeyword = std::make_shared(jsonObject); + const auto& parserKeyword = std::make_shared(jsonObject); BOOST_CHECK_EQUAL("BPR" , parserKeyword->getName()); BOOST_CHECK_EQUAL( true , parserKeyword->hasFixedSize() ); BOOST_CHECK_EQUAL( 100U , parserKeyword->getFixedSize() ); @@ -219,14 +219,14 @@ BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withSize) { BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_nosize_notItems_OK) { Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"]}"); - ParserKeywordConstPtr parserKeyword = std::make_shared(jsonObject); + const auto& parserKeyword = std::make_shared(jsonObject); BOOST_CHECK_EQUAL( true , parserKeyword->hasFixedSize() ); BOOST_CHECK_EQUAL( 0U , parserKeyword->getFixedSize()); } BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withSizeOther) { Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : {\"keyword\" : \"Bjarne\" , \"item\": \"BjarneIgjen\"}, \"items\" :[{\"name\":\"ItemX\" , \"value_type\" : \"DOUBLE\"}]}"); - ParserKeywordConstPtr parserKeyword = std::make_shared(jsonObject); + const auto& parserKeyword = std::make_shared(jsonObject); const std::pair& sizeKW = parserKeyword->getSizeDefinitionPair(); BOOST_CHECK_EQUAL("BPR" , parserKeyword->getName()); BOOST_CHECK_EQUAL( false , parserKeyword->hasFixedSize() ); @@ -268,9 +268,9 @@ BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_ItemInvalidEnum_throws) { BOOST_AUTO_TEST_CASE(ConstructFromJsonObjectItemsOK) { Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100 , \"items\" : [{\"name\" : \"I\", \"value_type\" : \"INT\"}]}"); - ParserKeywordConstPtr parserKeyword = std::make_shared(jsonObject); - ParserRecordConstPtr record = parserKeyword->getRecord(0); - ParserItemConstPtr item = record->get( 0 ); + const auto& parserKeyword = std::make_shared(jsonObject); + const auto& record = parserKeyword->getRecord(0); + const auto& item = record->get( 0 ); BOOST_CHECK_EQUAL( 1U , record->size( ) ); BOOST_CHECK_EQUAL( "I" , item->name( ) ); BOOST_CHECK_EQUAL( SINGLE , item->sizeType()); @@ -282,7 +282,7 @@ BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_sizeFromOther) { } BOOST_AUTO_TEST_CASE(Default_NotData) { - ParserKeywordConstPtr parserKeyword = createDynamicSized("BPR"); + auto parserKeyword = createDynamicSized("BPR"); BOOST_CHECK_EQUAL( false , parserKeyword->isDataKeyword()); } @@ -294,9 +294,9 @@ BOOST_AUTO_TEST_CASE(AddDataKeywordFromJson_defaultThrows) { BOOST_AUTO_TEST_CASE(AddDataKeywordFromJson_correctlyConfigured) { Json::JsonObject jsonConfig("{\"name\": \"ACTNUM\", \"sections\":[\"GRID\"], \"data\" : {\"value_type\": \"INT\"}}"); - ParserKeywordConstPtr parserKeyword = std::make_shared(jsonConfig); - ParserRecordConstPtr parserRecord = parserKeyword->getRecord(0); - ParserItemConstPtr item = parserRecord->get(0); + const auto& parserKeyword = std::make_shared(jsonConfig); + const auto& parserRecord = parserKeyword->getRecord(0); + const auto& item = parserRecord->get(0); BOOST_CHECK_EQUAL( true , parserKeyword->isDataKeyword()); @@ -314,9 +314,7 @@ BOOST_AUTO_TEST_CASE(AddkeywordFromJson_numTables_incoorect_throw) { BOOST_AUTO_TEST_CASE(AddkeywordFromJson_isTableCollection) { Json::JsonObject jsonConfig("{\"name\": \"PVTG\", \"sections\":[\"PROPS\"], \"num_tables\" : {\"keyword\": \"TABDIMS\" , \"item\" : \"NTPVT\"} , \"items\" : [{\"name\" : \"data\", \"value_type\" : \"DOUBLE\"}]}"); - ParserKeywordConstPtr parserKeyword = std::make_shared(jsonConfig); - ParserRecordConstPtr parserRecord = parserKeyword->getRecord(0); - + const auto& parserKeyword = std::make_shared(jsonConfig); BOOST_CHECK_EQUAL( true , parserKeyword->isTableCollection() ); BOOST_CHECK_EQUAL( false , parserKeyword->isDataKeyword()); @@ -333,21 +331,21 @@ BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_InvalidSize_throws) { BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_SizeUNKNOWN_OK) { Json::JsonObject jsonObject1("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : \"UNKNOWN\" , \"items\" : [{\"name\" : \"I\" , \"size_type\" : \"SINGLE\" , \"value_type\" : \"INT\"}]}"); - ParserKeywordConstPtr parserKeyword = std::make_shared(jsonObject1); + auto parserKeyword = std::make_shared(jsonObject1); BOOST_CHECK_EQUAL( UNKNOWN , parserKeyword->getSizeType() ); } BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_WithDescription_DescriptionPropertyShouldBePopulated) { Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"description\" : \"Description\"}"); - ParserKeywordConstPtr parserKeyword = std::make_shared(jsonObject); + auto parserKeyword = std::make_shared(jsonObject); BOOST_CHECK_EQUAL( "Description", parserKeyword->getDescription() ); } BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_WithoutDescription_DescriptionPropertyShouldBeEmpty) { Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"]}"); - ParserKeywordConstPtr parserKeyword = std::make_shared(jsonObject); + auto parserKeyword = std::make_shared(jsonObject); BOOST_CHECK_EQUAL( "", parserKeyword->getDescription() ); } @@ -355,35 +353,35 @@ BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_WithoutDescription_DescriptionPrope /* */ /*****************************************************************/ BOOST_AUTO_TEST_CASE(getFixedSize_sizeObjectHasFixedSize_sizeReturned) { - ParserKeywordPtr parserKeyword = createFixedSized("JA", (size_t) 3); + const auto& parserKeyword = createFixedSized("JA", (size_t) 3); BOOST_CHECK_EQUAL(3U, parserKeyword->getFixedSize()); } BOOST_AUTO_TEST_CASE(getFixedSize_sizeObjectDoesNotHaveFixedSizeObjectSet_ExceptionThrown) { - ParserKeywordPtr parserKeyword = createDynamicSized("JA"); + const auto& parserKeyword = createDynamicSized("JA"); BOOST_CHECK_THROW(parserKeyword->getFixedSize(), std::logic_error); } BOOST_AUTO_TEST_CASE(hasFixedSize_hasFixedSizeObject_returnstrue) { - ParserKeywordPtr parserKeyword = createFixedSized("JA", (size_t) 2); + const auto& parserKeyword = createFixedSized("JA", (size_t) 2); BOOST_CHECK(parserKeyword->hasFixedSize()); } BOOST_AUTO_TEST_CASE(hasFixedSize_sizeObjectDoesNotHaveFixedSize_returnsfalse) { - ParserKeywordPtr parserKeyword = createDynamicSized("JA"); + const auto& parserKeyword = createDynamicSized("JA"); BOOST_CHECK(!parserKeyword->hasFixedSize()); } /******/ /* Tables: */ BOOST_AUTO_TEST_CASE(DefaultIsNot_TableKeyword) { - ParserKeywordPtr parserKeyword = createDynamicSized("JA"); + const auto& parserKeyword = createDynamicSized("JA"); BOOST_CHECK(!parserKeyword->isTableCollection()); } BOOST_AUTO_TEST_CASE(ConstructorIsTableCollection) { - ParserKeywordPtr parserKeyword = createTable("JA" , "TABDIMS" , "NTPVT" , true); + const auto& parserKeyword = createTable("JA" , "TABDIMS" , "NTPVT" , true); const std::pair& sizeKW = parserKeyword->getSizeDefinitionPair(); BOOST_CHECK(parserKeyword->isTableCollection()); BOOST_CHECK(!parserKeyword->hasFixedSize()); @@ -394,10 +392,10 @@ BOOST_AUTO_TEST_CASE(ConstructorIsTableCollection) { } BOOST_AUTO_TEST_CASE(ParseEmptyRecord) { - ParserKeywordPtr tabdimsKeyword = createFixedSized("TEST" , 1); + const auto& tabdimsKeyword = createFixedSized("TEST" , 1); std::shared_ptr record = std::make_shared(); - ParserIntItemConstPtr item(new ParserIntItem(std::string("ITEM") , ALL)); - RawKeywordPtr rawkeyword(new RawKeyword( tabdimsKeyword->getName() , "FILE" , 10U , 1)); + auto item = std::make_shared< ParserIntItem >(std::string("ITEM") , ALL); + auto rawkeyword = std::make_shared< RawKeyword >( tabdimsKeyword->getName() , "FILE" , 10U , 1 ); ParseContext parseContext; MessageContainer msgContainer; @@ -420,9 +418,9 @@ BOOST_AUTO_TEST_CASE(ParseEmptyRecord) { /*****************************************************************/ /* Dimension */ BOOST_AUTO_TEST_CASE(ParseKeywordHasDimensionCorrect) { - ParserKeywordPtr parserKeyword = createDynamicSized("JA"); - ParserIntItemConstPtr itemI(new ParserIntItem("I", SINGLE)); - ParserDoubleItemPtr item2(new ParserDoubleItem("ID", SINGLE)); + const auto& parserKeyword = createDynamicSized("JA"); + const auto& itemI = std::make_shared< ParserIntItem >("I", SINGLE); + const auto& item2 = std::make_shared< ParserDoubleItem >("ID", SINGLE); std::shared_ptr record = std::make_shared(); BOOST_CHECK_EQUAL( false , parserKeyword->hasDimension()); @@ -440,9 +438,9 @@ BOOST_AUTO_TEST_CASE(ParseKeywordHasDimensionCorrect) { BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withDimension) { Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\" , \"dimension\" : \"Length*Length/Time\"}]}"); - ParserKeywordPtr parserKeyword = std::make_shared(jsonObject); - ParserRecordConstPtr record = parserKeyword->getRecord(0); - ParserItemConstPtr item = record->get("ItemX"); + const auto& parserKeyword = std::make_shared(jsonObject); + const auto& record = parserKeyword->getRecord(0); + const auto& item = record->get("ItemX"); BOOST_CHECK_EQUAL("BPR" , parserKeyword->getName()); BOOST_CHECK_EQUAL( true , parserKeyword->hasFixedSize() ); @@ -455,9 +453,9 @@ BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withDimension) { BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withDimensionList) { Json::JsonObject jsonObject("{\"name\": \"BPR\", \"sections\":[\"SUMMARY\"], \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"ALL\" , \"value_type\" : \"DOUBLE\" , \"dimension\" : [\"Length*Length/Time\" , \"Time\", \"1\"]}]}"); - ParserKeywordPtr parserKeyword = std::make_shared(jsonObject); - ParserRecordConstPtr record = parserKeyword->getRecord(0); - ParserItemConstPtr item = record->get("ItemX"); + const auto& parserKeyword = std::make_shared(jsonObject); + const auto& record = parserKeyword->getRecord(0); + const auto& item = record->get("ItemX"); BOOST_CHECK_EQUAL("BPR" , parserKeyword->getName()); BOOST_CHECK_EQUAL( true , parserKeyword->hasFixedSize() ); @@ -484,8 +482,8 @@ BOOST_AUTO_TEST_CASE(ConstructFromJson_withRecords) { Json::JsonObject jsonObject1( json_string1 ); Json::JsonObject jsonObject2( json_string2 ); - ParserKeywordPtr kw1 = std::make_shared( jsonObject1 ); - ParserKeywordPtr kw2 = std::make_shared( jsonObject2 ); + auto kw1 = std::make_shared( jsonObject1 ); + auto kw2 = std::make_shared( jsonObject2 ); BOOST_CHECK( kw1->equal( *kw2 )); diff --git a/opm/parser/eclipse/Parser/tests/ParserRecordTests.cpp b/opm/parser/eclipse/Parser/tests/ParserRecordTests.cpp index d1912a962..2a3633ef5 100644 --- a/opm/parser/eclipse/Parser/tests/ParserRecordTests.cpp +++ b/opm/parser/eclipse/Parser/tests/ParserRecordTests.cpp @@ -41,176 +41,156 @@ BOOST_AUTO_TEST_CASE(DefaultConstructor_NoParams_NoThrow) { BOOST_CHECK_NO_THROW(ParserRecord record); } -BOOST_AUTO_TEST_CASE(InitSharedPointer_NoThrow) { - BOOST_CHECK_NO_THROW(ParserRecordConstPtr ptr(new ParserRecord())); - BOOST_CHECK_NO_THROW(ParserRecordPtr ptr(new ParserRecord())); -} - BOOST_AUTO_TEST_CASE(Size_NoElements_ReturnsZero) { ParserRecord record; BOOST_CHECK_EQUAL(0U, record.size()); } BOOST_AUTO_TEST_CASE(Size_OneItem_Return1) { - ParserItemSizeEnum sizeType = SINGLE; - ParserIntItemPtr itemInt(new ParserIntItem("ITEM1", sizeType)); - ParserRecordPtr record(new ParserRecord()); - record->addItem(itemInt); - BOOST_CHECK_EQUAL(1U, record->size()); + auto itemInt = std::make_shared< ParserIntItem >("ITEM1", SINGLE ); + ParserRecord record; + record.addItem(itemInt); + BOOST_CHECK_EQUAL(1U, record.size()); } BOOST_AUTO_TEST_CASE(Get_OneItem_Return1) { - ParserItemSizeEnum sizeType = SINGLE; - ParserIntItemPtr itemInt(new ParserIntItem("ITEM1", sizeType)); - ParserRecordPtr record(new ParserRecord()); - record->addItem(itemInt); - { - ParserItemConstPtr item = record->get(0); - BOOST_CHECK_EQUAL(item, itemInt); - } + auto itemInt = std::make_shared< ParserIntItem >("ITEM1", SINGLE); + ParserRecord record; + record.addItem(itemInt); + + BOOST_CHECK_EQUAL(record.get(0), itemInt); } BOOST_AUTO_TEST_CASE(Get_outOfRange_Throw) { - ParserRecordConstPtr record(new ParserRecord()); - BOOST_CHECK_THROW(record->get(0), std::out_of_range); + BOOST_CHECK_THROW(ParserRecord{}.get(0), std::out_of_range); } BOOST_AUTO_TEST_CASE(Get_KeyNotFound_Throw) { - ParserRecordPtr record(new ParserRecord()); - BOOST_CHECK_THROW(record->get("Hei"), std::invalid_argument); + ParserRecord record; + BOOST_CHECK_THROW(record.get("Hei"), std::out_of_range ); } BOOST_AUTO_TEST_CASE(Get_KeyFound_OK) { - ParserItemSizeEnum sizeType = SINGLE; - ParserIntItemPtr itemInt(new ParserIntItem("ITEM1", sizeType)); - ParserRecordPtr record(new ParserRecord()); - record->addItem(itemInt); - { - ParserItemConstPtr item = record->get("ITEM1"); - BOOST_CHECK_EQUAL(item, itemInt); - } + auto itemInt = std::make_shared< ParserIntItem >("ITEM1", SINGLE ); + ParserRecord record; + record.addItem(itemInt); + BOOST_CHECK_EQUAL(record.get("ITEM1"), itemInt); } BOOST_AUTO_TEST_CASE(Get_GetByNameAndIndex_OK) { - ParserItemSizeEnum sizeType = SINGLE; - ParserIntItemPtr itemInt(new ParserIntItem("ITEM1", sizeType)); - ParserRecordPtr record(new ParserRecord()); - record->addItem(itemInt); - { - ParserItemConstPtr itemByName = record->get("ITEM1"); - ParserItemConstPtr itemByIndex = record->get(0); - BOOST_CHECK_EQUAL(itemInt, itemByName); - BOOST_CHECK_EQUAL(itemInt, itemByIndex); - } + auto itemInt = std::make_shared< ParserIntItem >("ITEM1", SINGLE); + ParserRecord record; + record.addItem(itemInt); + + const auto& itemByName = record.get("ITEM1"); + const auto& itemByIndex = record.get(0); + BOOST_CHECK_EQUAL(itemInt, itemByName); + BOOST_CHECK_EQUAL(itemInt, itemByIndex); } BOOST_AUTO_TEST_CASE(addItem_SameName_Throw) { - ParserItemSizeEnum sizeType = SINGLE; - ParserIntItemPtr itemInt1(new ParserIntItem("ITEM1", sizeType)); - ParserIntItemPtr itemInt2(new ParserIntItem("ITEM1", sizeType)); - ParserRecordPtr record(new ParserRecord()); - record->addItem(itemInt1); - BOOST_CHECK_THROW(record->addItem(itemInt2), std::invalid_argument); + auto itemInt1 = std::make_shared< ParserIntItem >("ITEM1", SINGLE); + auto itemInt2 = std::make_shared< ParserIntItem >("ITEM1", SINGLE); + ParserRecord record; + record.addItem(itemInt1); + BOOST_CHECK_THROW(record.addItem(itemInt2), std::invalid_argument); } -static ParserRecordPtr createSimpleParserRecord() { - ParserItemSizeEnum sizeType = SINGLE; - ParserIntItemPtr itemInt1(new ParserIntItem("ITEM1", sizeType)); - ParserIntItemPtr itemInt2(new ParserIntItem("ITEM2", sizeType)); - ParserRecordPtr record(new ParserRecord()); - - record->addItem(itemInt1); - record->addItem(itemInt2); +static ParserRecord createSimpleParserRecord() { + auto itemInt1 = std::make_shared< ParserIntItem >("ITEM1", SINGLE); + auto itemInt2 = std::make_shared< ParserIntItem >("ITEM2", SINGLE); + ParserRecord record; + record.addItem(itemInt1); + record.addItem(itemInt2); return record; } BOOST_AUTO_TEST_CASE(parse_validRecord_noThrow) { - ParserRecordPtr record = createSimpleParserRecord(); + auto record = createSimpleParserRecord(); ParseContext parseContext; RawRecord raw( string_view( "100 443" ) ); MessageContainer msgContainer; - BOOST_CHECK_NO_THROW(record->parse(parseContext, msgContainer, raw ) ); + BOOST_CHECK_NO_THROW(record.parse(parseContext, msgContainer, raw ) ); } BOOST_AUTO_TEST_CASE(parse_validRecord_deckRecordCreated) { - ParserRecordPtr record = createSimpleParserRecord(); + auto record = createSimpleParserRecord(); RawRecord rawRecord( string_view( "100 443" ) ); ParseContext parseContext; MessageContainer msgContainer; - const auto deckRecord = record->parse(parseContext , msgContainer, rawRecord); + const auto deckRecord = record.parse(parseContext , msgContainer, rawRecord); BOOST_CHECK_EQUAL(2U, deckRecord.size()); } // INT INT DOUBLE DOUBLE INT DOUBLE -static ParserRecordPtr createMixedParserRecord() { +static ParserRecord createMixedParserRecord() { ParserItemSizeEnum sizeType = SINGLE; - ParserIntItemPtr itemInt1(new ParserIntItem("INTITEM1", sizeType)); - ParserIntItemPtr itemInt2(new ParserIntItem("INTITEM2", sizeType)); - ParserDoubleItemPtr itemDouble1(new ParserDoubleItem("DOUBLEITEM1", sizeType)); - ParserDoubleItemPtr itemDouble2(new ParserDoubleItem("DOUBLEITEM2", sizeType)); + auto itemInt1 = std::make_shared< ParserIntItem >("INTITEM1", sizeType); + auto itemInt2 = std::make_shared< ParserIntItem >("INTITEM2", sizeType); + auto itemInt3 = std::make_shared< ParserIntItem >("INTITEM3", sizeType); + auto itemDouble1 = std::make_shared< ParserDoubleItem >("DOUBLEITEM1", sizeType); + auto itemDouble2 = std::make_shared< ParserDoubleItem >("DOUBLEITEM2", sizeType); + auto itemDouble3 = std::make_shared< ParserDoubleItem >("DOUBLEITEM3", sizeType); - ParserIntItemPtr itemInt3(new ParserIntItem("INTITEM3", sizeType)); - ParserDoubleItemPtr itemDouble3(new ParserDoubleItem("DOUBLEITEM3", sizeType)); - - ParserRecordPtr record(new ParserRecord()); - record->addItem(itemInt1); - record->addItem(itemInt2); - record->addItem(itemDouble1); - record->addItem(itemDouble2); - record->addItem(itemInt3); - record->addItem(itemDouble3); + ParserRecord record; + record.addItem(itemInt1); + record.addItem(itemInt2); + record.addItem(itemDouble1); + record.addItem(itemDouble2); + record.addItem(itemInt3); + record.addItem(itemDouble3); return record; } BOOST_AUTO_TEST_CASE(parse_validMixedRecord_noThrow) { - ParserRecordPtr record = createMixedParserRecord(); + auto record = createMixedParserRecord(); RawRecord rawRecord( string_view( "1 2 10.0 20.0 4 90.0") ); ParseContext parseContext; MessageContainer msgContainer; - BOOST_CHECK_NO_THROW(record->parse(parseContext , msgContainer, rawRecord)); + BOOST_CHECK_NO_THROW(record.parse(parseContext , msgContainer, rawRecord)); } BOOST_AUTO_TEST_CASE(Equal_Equal_ReturnsTrue) { - ParserRecordPtr record1 = createMixedParserRecord(); - ParserRecordPtr record2 = createMixedParserRecord(); + auto record1 = createMixedParserRecord(); + auto record2 = createMixedParserRecord(); - BOOST_CHECK(record1->equal(*record1)); - BOOST_CHECK(record1->equal(*record2)); + BOOST_CHECK(record1.equal(record1)); + BOOST_CHECK(record1.equal(record2)); } BOOST_AUTO_TEST_CASE(Equal_Different_ReturnsFalse) { ParserItemSizeEnum sizeType = SINGLE; - ParserIntItemPtr itemInt(new ParserIntItem("INTITEM1", sizeType, 0)); - ParserDoubleItemPtr itemDouble(new ParserDoubleItem("DOUBLEITEM1", sizeType, 0)); - ParserStringItemPtr itemString(new ParserStringItem("STRINGITEM1", sizeType)); - ParserRecordPtr record1(new ParserRecord()); - ParserRecordPtr record2(new ParserRecord()); - ParserRecordPtr record3(new ParserRecord()); + auto itemInt = std::make_shared< ParserIntItem >("INTITEM1", sizeType, 0); + auto itemDouble = std::make_shared< ParserDoubleItem >("DOUBLEITEM1", sizeType, 0); + auto itemString = std::make_shared< ParserStringItem >("STRINGITEM1", sizeType); + ParserRecord record1; + ParserRecord record2; + ParserRecord record3; - record1->addItem(itemInt); - record1->addItem(itemDouble); + record1.addItem(itemInt); + record1.addItem(itemDouble); - record2->addItem(itemInt); - record2->addItem(itemDouble); - record2->addItem(itemString); + record2.addItem(itemInt); + record2.addItem(itemDouble); + record2.addItem(itemString); - record3->addItem(itemDouble); - record3->addItem(itemInt); - BOOST_CHECK(!record1->equal(*record2)); - BOOST_CHECK(!record1->equal(*record3)); + record3.addItem(itemDouble); + record3.addItem(itemInt); + BOOST_CHECK(!record1.equal(record2)); + BOOST_CHECK(!record1.equal(record3)); } BOOST_AUTO_TEST_CASE(ParseWithDefault_defaultAppliedCorrectInDeck) { ParserRecord parserRecord; - ParserIntItemConstPtr itemInt(new ParserIntItem("ITEM1", SINGLE , 100)); - ParserStringItemConstPtr itemString(new ParserStringItem("ITEM2", SINGLE , "DEFAULT")); - ParserDoubleItemConstPtr itemDouble(new ParserDoubleItem("ITEM3", SINGLE , 3.14 )); + auto itemInt = std::make_shared< ParserIntItem >("ITEM1", SINGLE , 100); + auto itemString = std::make_shared< ParserStringItem >("ITEM2", SINGLE , "DEFAULT"); + auto itemDouble = std::make_shared< ParserDoubleItem >("ITEM3", SINGLE , 3.14 ); parserRecord.addItem(itemInt); parserRecord.addItem(itemString); @@ -300,48 +280,48 @@ BOOST_AUTO_TEST_CASE(ParseWithDefault_defaultAppliedCorrectInDeck) { } BOOST_AUTO_TEST_CASE(Parse_RawRecordTooManyItems_Throws) { - ParserRecordPtr parserRecord(new ParserRecord()); - ParserIntItemConstPtr itemI(new ParserIntItem("I", SINGLE)); - ParserIntItemConstPtr itemJ(new ParserIntItem("J", SINGLE)); - ParserIntItemConstPtr itemK(new ParserIntItem("K", SINGLE)); + ParserRecord parserRecord; + auto itemI = std::make_shared< ParserIntItem >("I", SINGLE); + auto itemJ = std::make_shared< ParserIntItem >("J", SINGLE); + auto itemK = std::make_shared< ParserIntItem >("K", SINGLE); ParseContext parseContext; - parserRecord->addItem(itemI); - parserRecord->addItem(itemJ); - parserRecord->addItem(itemK); + parserRecord.addItem(itemI); + parserRecord.addItem(itemJ); + parserRecord.addItem(itemK); RawRecord rawRecord( "3 3 3 " ); MessageContainer msgContainer; - BOOST_CHECK_NO_THROW(parserRecord->parse(parseContext , msgContainer, rawRecord)); + BOOST_CHECK_NO_THROW(parserRecord.parse(parseContext , msgContainer, rawRecord)); RawRecord rawRecordOneExtra( "3 3 3 4 " ); - BOOST_CHECK_THROW(parserRecord->parse(parseContext , msgContainer, rawRecordOneExtra), std::invalid_argument); + BOOST_CHECK_THROW(parserRecord.parse(parseContext , msgContainer, rawRecordOneExtra), std::invalid_argument); RawRecord rawRecordForgotRecordTerminator( "3 3 3 \n 4 4 4 " ); - BOOST_CHECK_THROW(parserRecord->parse(parseContext , msgContainer, rawRecordForgotRecordTerminator), std::invalid_argument); + BOOST_CHECK_THROW(parserRecord.parse(parseContext , msgContainer, rawRecordForgotRecordTerminator), std::invalid_argument); } BOOST_AUTO_TEST_CASE(Parse_RawRecordTooFewItems) { - ParserRecordPtr parserRecord(new ParserRecord()); - ParserIntItemConstPtr itemI(new ParserIntItem("I", SINGLE)); - ParserIntItemConstPtr itemJ(new ParserIntItem("J", SINGLE)); - ParserIntItemConstPtr itemK(new ParserIntItem("K", SINGLE)); + ParserRecord parserRecord; + auto itemI = std::make_shared< ParserIntItem >("I", SINGLE); + auto itemJ = std::make_shared< ParserIntItem >("J", SINGLE); + auto itemK = std::make_shared< ParserIntItem >("K", SINGLE); - parserRecord->addItem(itemI); - parserRecord->addItem(itemJ); - parserRecord->addItem(itemK); + parserRecord.addItem(itemI); + parserRecord.addItem(itemJ); + parserRecord.addItem(itemK); ParseContext parseContext; RawRecord rawRecord( "3 3 " ); // no default specified for the third item, record can be parsed just fine but trying // to access the data will raise an exception... MessageContainer msgContainer; - BOOST_CHECK_NO_THROW(parserRecord->parse(parseContext , msgContainer, rawRecord)); - auto record = parserRecord->parse(parseContext , msgContainer, rawRecord); + BOOST_CHECK_NO_THROW(parserRecord.parse(parseContext , msgContainer, rawRecord)); + auto record = parserRecord.parse(parseContext , msgContainer, rawRecord); BOOST_CHECK_NO_THROW(record.getItem(2)); BOOST_CHECK_THROW(record.getItem(2).get< int >(0), std::out_of_range); } @@ -349,18 +329,18 @@ BOOST_AUTO_TEST_CASE(Parse_RawRecordTooFewItems) { BOOST_AUTO_TEST_CASE(ParseRecordHasDimensionCorrect) { - ParserRecordPtr parserRecord(new ParserRecord()); - ParserIntItemConstPtr itemI(new ParserIntItem("I", SINGLE)); - ParserDoubleItemPtr item2(new ParserDoubleItem("ID", SINGLE)); + ParserRecord parserRecord; + auto itemI = std::make_shared< ParserIntItem >( "I", SINGLE ); + auto item2 = std::make_shared< ParserDoubleItem >( "ID", SINGLE ); - BOOST_CHECK_EQUAL( false , parserRecord->hasDimension()); + BOOST_CHECK( !parserRecord.hasDimension() ); - parserRecord->addItem( itemI ); - parserRecord->addItem( item2 ); - BOOST_CHECK_EQUAL( false , parserRecord->hasDimension()); + parserRecord.addItem( itemI ); + parserRecord.addItem( item2 ); + BOOST_CHECK( !parserRecord.hasDimension() ); item2->push_backDimension("Length*Length/Time"); - BOOST_CHECK_EQUAL( true , parserRecord->hasDimension()); + BOOST_CHECK( parserRecord.hasDimension() ); } @@ -369,12 +349,10 @@ BOOST_AUTO_TEST_CASE(DefaultNotDataRecord) { BOOST_CHECK_EQUAL( false , record.isDataRecord() ); } - - BOOST_AUTO_TEST_CASE(MixingDataAndItems_throws1) { ParserRecord record; - ParserIntItemConstPtr dataItem = ParserIntItemConstPtr(new ParserIntItem( "ACTNUM" , ALL)); - ParserIntItemConstPtr item = ParserIntItemConstPtr(new ParserIntItem( "XXX" , ALL)); + auto dataItem = std::make_shared< ParserIntItem >( "ACTNUM" , ALL); + auto item = std::make_shared< ParserIntItem >( "XXX" , ALL); record.addDataItem( dataItem ); BOOST_CHECK_THROW( record.addItem( item ) , std::invalid_argument); BOOST_CHECK_THROW( record.addItem( dataItem ) , std::invalid_argument); @@ -382,8 +360,8 @@ BOOST_AUTO_TEST_CASE(MixingDataAndItems_throws1) { BOOST_AUTO_TEST_CASE(MixingDataAndItems_throws2) { ParserRecord record; - ParserIntItemConstPtr dataItem = ParserIntItemConstPtr(new ParserIntItem( "ACTNUM" , ALL)); - ParserIntItemConstPtr item = ParserIntItemConstPtr(new ParserIntItem( "XXX" , ALL)); + auto dataItem = std::make_shared< ParserIntItem >( "ACTNUM" , ALL); + auto item = std::make_shared< ParserIntItem >( "XXX" , ALL); record.addItem( item ); BOOST_CHECK_THROW( record.addDataItem( dataItem ) , std::invalid_argument); diff --git a/opm/parser/eclipse/RawDeck/RawKeyword.hpp b/opm/parser/eclipse/RawDeck/RawKeyword.hpp index 6ce0809e8..5725d5d5e 100644 --- a/opm/parser/eclipse/RawDeck/RawKeyword.hpp +++ b/opm/parser/eclipse/RawDeck/RawKeyword.hpp @@ -91,9 +91,6 @@ namespace Opm { void setKeywordName(const std::string& keyword); static bool isValidKeyword(const std::string& keywordCandidate); }; - typedef std::shared_ptr RawKeywordPtr; - typedef std::shared_ptr RawKeywordConstPtr; - } #endif /* RAWKEYWORD_HPP */ diff --git a/opm/parser/eclipse/RawDeck/RawRecord.hpp b/opm/parser/eclipse/RawDeck/RawRecord.hpp index 783f1618f..716b0146a 100644 --- a/opm/parser/eclipse/RawDeck/RawRecord.hpp +++ b/opm/parser/eclipse/RawDeck/RawRecord.hpp @@ -59,8 +59,6 @@ namespace Opm { void setRecordString(const std::string& singleRecordString); }; - typedef std::shared_ptr RawRecordPtr; - typedef std::shared_ptr RawRecordConstPtr; /* * These are frequently called, but fairly trivial in implementation, and diff --git a/opm/parser/eclipse/RawDeck/tests/RawRecordTests.cpp b/opm/parser/eclipse/RawDeck/tests/RawRecordTests.cpp index b95e31f92..732588bb4 100644 --- a/opm/parser/eclipse/RawDeck/tests/RawRecordTests.cpp +++ b/opm/parser/eclipse/RawDeck/tests/RawRecordTests.cpp @@ -24,14 +24,14 @@ BOOST_AUTO_TEST_CASE(RawRecordGetRecordsCorrectElementsReturned) { - Opm::RawRecordPtr record(new Opm::RawRecord(" 'NODIR ' 'REVERS' 1 20 ")); + Opm::RawRecord record(" 'NODIR ' 'REVERS' 1 20 "); - BOOST_CHECK_EQUAL((unsigned) 4, record->size()); + BOOST_CHECK_EQUAL((unsigned) 4, record.size()); - BOOST_CHECK_EQUAL("'NODIR '", record->getItem(0)); - BOOST_CHECK_EQUAL("'REVERS'", record->getItem(1)); - BOOST_CHECK_EQUAL("1", record->getItem(2)); - BOOST_CHECK_EQUAL("20", record->getItem(3)); + BOOST_CHECK_EQUAL("'NODIR '", record.getItem(0)); + BOOST_CHECK_EQUAL("'REVERS'", record.getItem(1)); + BOOST_CHECK_EQUAL("1", record.getItem(2)); + BOOST_CHECK_EQUAL("20", record.getItem(3)); } BOOST_AUTO_TEST_CASE(RawRecordIsCompleteRecordCompleteRecordReturnsTrue) { @@ -46,60 +46,52 @@ BOOST_AUTO_TEST_CASE(RawRecordIsCompleteRecordInCompleteRecordReturnsFalse) { BOOST_AUTO_TEST_CASE(Rawrecord_OperatorThis_OK) { Opm::RawRecord record(" 'NODIR ' 'REVERS' 1 20 "); - Opm::RawRecordPtr recordPtr(new Opm::RawRecord(" 'NODIR ' 'REVERS' 1 20 ")); BOOST_CHECK_EQUAL("'NODIR '", record.getItem(0)); BOOST_CHECK_EQUAL("'REVERS'", record.getItem(1)); BOOST_CHECK_EQUAL("1", record.getItem(2)); BOOST_CHECK_EQUAL("20", record.getItem(3)); - - BOOST_CHECK_EQUAL("20", recordPtr->getItem(3)); - BOOST_CHECK_THROW(record.getItem(4), std::out_of_range); } BOOST_AUTO_TEST_CASE(Rawrecord_PushFront_OK) { - Opm::RawRecordPtr record(new Opm::RawRecord(" 'NODIR ' 'REVERS' 1 20 ")); - record->prepend( 1, "String2" ); - record->prepend( 1, "String1" ); + Opm::RawRecord record(" 'NODIR ' 'REVERS' 1 20 "); + record.prepend( 1, "String2" ); + record.prepend( 1, "String1" ); - - BOOST_CHECK_EQUAL("String1", record->getItem(0)); - BOOST_CHECK_EQUAL("String2", record->getItem(1)); + BOOST_CHECK_EQUAL("String1", record.getItem(0)); + BOOST_CHECK_EQUAL("String2", record.getItem(1)); } BOOST_AUTO_TEST_CASE(Rawrecord_size_OK) { - Opm::RawRecordPtr record(new Opm::RawRecord(" 'NODIR ' 'REVERS' 1 20 ")); + Opm::RawRecord record(" 'NODIR ' 'REVERS' 1 20 "); - BOOST_CHECK_EQUAL(4U, record->size()); - record->prepend( 1, "String2"); - record->prepend( 1, "String1"); - BOOST_CHECK_EQUAL(6U, record->size()); + BOOST_CHECK_EQUAL(4U, record.size()); + record.prepend( 1, "String2"); + record.prepend( 1, "String1"); + BOOST_CHECK_EQUAL(6U, record.size()); } BOOST_AUTO_TEST_CASE(Rawrecord_sizeEmpty_OK) { - Opm::RawRecordPtr record(new Opm::RawRecord("")); - BOOST_CHECK_EQUAL(0U, record->size()); + Opm::RawRecord record(""); + BOOST_CHECK_EQUAL(0U, record.size()); } BOOST_AUTO_TEST_CASE(Rawrecord_spaceOnlyEmpty_OK) { - Opm::RawRecordPtr record(new Opm::RawRecord(" ")); - BOOST_CHECK_EQUAL(0U, record->size()); + Opm::RawRecord record(" "); + BOOST_CHECK_EQUAL(0U, record.size()); } BOOST_AUTO_TEST_CASE(Rawrecord_noFileAndKeywordGiven_EmptyStringUsed) { - Opm::RawRecordPtr record(new Opm::RawRecord("32 33 ")); - BOOST_CHECK_EQUAL("", record->getKeywordName()); - BOOST_CHECK_EQUAL("", record->getFileName()); + Opm::RawRecord record("32 33 "); + BOOST_CHECK_EQUAL("", record.getKeywordName()); + BOOST_CHECK_EQUAL("", record.getFileName()); } BOOST_AUTO_TEST_CASE(Rawrecord_FileAndKeywordGiven_CorrectStringsReturned) { const std::string fileName = "/this/is/it"; const std::string keywordName = "KEYWD"; - Opm::RawRecordPtr record(new Opm::RawRecord("32 33 ", fileName, keywordName)); - BOOST_CHECK_EQUAL(keywordName, record->getKeywordName()); - BOOST_CHECK_EQUAL(fileName, record->getFileName()); + Opm::RawRecord record("32 33 ", fileName, keywordName); + BOOST_CHECK_EQUAL(keywordName, record.getKeywordName()); + BOOST_CHECK_EQUAL(fileName, record.getFileName()); } - - -