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

Merge remote-tracking branch 'upstream/master' into norne-keywords

Browse Source
This commit is contained in:
Joakim Hove
2013-12-02 13:21:00 +01:00
parent 679d79dd6f 7619067e7a
commit f1e9230911
30 changed files with 125 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
opm/parser/eclipse/Deck/Deck.hpp
View File

@@ -21,8 +21,7 @@
#define DECK_HPP
#include <vector>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <opm/parser/eclipse/Deck/KeywordContainer.hpp>
@@ -48,8 +47,8 @@ namespace Opm {
std::vector<std::pair<std::string , std::pair<std::string,size_t> > > m_warnings; //<"Warning Text" , <"Filename" , LineNR>>
};
typedef boost::shared_ptr<Deck> DeckPtr;
typedef boost::shared_ptr<const Deck> DeckConstPtr;
typedef std::shared_ptr<Deck> DeckPtr;
typedef std::shared_ptr<const Deck> DeckConstPtr;
}
#endif /* DECK_HPP */

7
opm/parser/eclipse/Deck/DeckDoubleItem.hpp
View File

@@ -23,7 +23,8 @@
#include <vector>
#include <string>
#include <deque>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
namespace Opm {
@@ -45,8 +46,8 @@ namespace Opm {
std::vector<double> m_data;
};
typedef boost::shared_ptr<DeckDoubleItem> DeckDoubleItemPtr;
typedef boost::shared_ptr<const DeckDoubleItem> DeckDoubleItemConstPtr;
typedef std::shared_ptr<DeckDoubleItem> DeckDoubleItemPtr;
typedef std::shared_ptr< const DeckDoubleItem> DeckDoubleItemConstPtr;
}
#endif /* DECKDOUBLEITEM_HPP */

6
opm/parser/eclipse/Deck/DeckIntItem.hpp
View File

@@ -23,7 +23,7 @@
#include <string>
#include <vector>
#include <deque>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
namespace Opm {
@@ -46,8 +46,8 @@ namespace Opm {
std::vector<int> m_data;
};
typedef boost::shared_ptr<DeckIntItem> DeckIntItemPtr;
typedef boost::shared_ptr<const DeckIntItem> DeckIntItemConstPtr;
typedef std::shared_ptr<DeckIntItem> DeckIntItemPtr;
typedef std::shared_ptr<const DeckIntItem> DeckIntItemConstPtr;
}
#endif /* DECKINTITEM_HPP */

7
opm/parser/eclipse/Deck/DeckItem.hpp
View File

@@ -23,8 +23,7 @@
#include <stdexcept>
#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <memory>
namespace Opm {
@@ -77,8 +76,8 @@ namespace Opm {
std::string m_name;
};
typedef boost::shared_ptr<DeckItem> DeckItemPtr;
typedef boost::shared_ptr<const DeckItem> DeckItemConstPtr;
typedef std::shared_ptr<DeckItem> DeckItemPtr;
typedef std::shared_ptr<const DeckItem> DeckItemConstPtr;
}
#endif /* DECKITEM_HPP */

6
opm/parser/eclipse/Deck/DeckKeyword.hpp
View File

@@ -10,7 +10,7 @@
#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
@@ -41,8 +41,8 @@ namespace Opm {
bool m_knownKeyword;
ssize_t m_deckIndex;
};
typedef boost::shared_ptr<DeckKeyword> DeckKeywordPtr;
typedef boost::shared_ptr<const DeckKeyword> DeckKeywordConstPtr;
typedef std::shared_ptr<DeckKeyword> DeckKeywordPtr;
typedef std::shared_ptr<const DeckKeyword> DeckKeywordConstPtr;
}
#endif /* DECKKEYWORD_HPP */

6
opm/parser/eclipse/Deck/DeckRecord.hpp
View File

@@ -24,7 +24,7 @@
#include <string>
#include <vector>
#include <map>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
namespace Opm {
@@ -42,8 +42,8 @@ namespace Opm {
std::map<std::string, DeckItemConstPtr> m_itemMap;
};
typedef boost::shared_ptr<DeckRecord> DeckRecordPtr;
typedef boost::shared_ptr<const DeckRecord> DeckRecordConstPtr;
typedef std::shared_ptr<DeckRecord> DeckRecordPtr;
typedef std::shared_ptr<const DeckRecord> DeckRecordConstPtr;
}
#endif /* DECKRECORD_HPP */

6
opm/parser/eclipse/Deck/DeckStringItem.hpp
View File

@@ -23,7 +23,7 @@
#include <string>
#include <vector>
#include <deque>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
namespace Opm {
@@ -47,8 +47,8 @@ namespace Opm {
std::vector<std::string> m_data;
};
typedef boost::shared_ptr<DeckStringItem> DeckStringItemPtr;
typedef boost::shared_ptr<const DeckStringItem> DeckStringItemConstPtr;
typedef std::shared_ptr<DeckStringItem> DeckStringItemPtr;
typedef std::shared_ptr<const DeckStringItem> DeckStringItemConstPtr;
}
#endif

6
opm/parser/eclipse/Deck/KeywordContainer.hpp
View File

@@ -11,7 +11,7 @@
#include <vector>
#include <map>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
@@ -34,8 +34,8 @@ namespace Opm {
std::vector<DeckKeywordConstPtr> m_keywordList;
std::map<std::string, std::vector<DeckKeywordConstPtr> > m_keywordMap;
};
typedef boost::shared_ptr<KeywordContainer> KeywordContainerPtr;
typedef boost::shared_ptr<const KeywordContainer> KeywordContainerConstPtr;
typedef std::shared_ptr<KeywordContainer> KeywordContainerPtr;
typedef std::shared_ptr<const KeywordContainer> KeywordContainerConstPtr;
}
#endif /* KEYWORDCONTAINER_HPP */

9
opm/parser/eclipse/EclipseState/Schedule/Completion.hpp
View File

@@ -21,6 +21,7 @@
#ifndef COMPLETION_HPP_
#define COMPLETION_HPP_
#include <memory>
#include <boost/date_time.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
@@ -40,8 +41,8 @@ namespace Opm {
CompletionStateEnum getState() const;
double getCF() const;
static std::map<std::string , std::vector<boost::shared_ptr<const Completion> > > completionsFromCOMPDATKeyword( DeckKeywordConstPtr compdatKeyword );
static std::pair<std::string , std::vector<boost::shared_ptr<const Completion> > > completionsFromCOMPDATRecord( DeckRecordConstPtr compdatRecord );
static std::map<std::string , std::vector<std::shared_ptr<const Completion> > > completionsFromCOMPDATKeyword( DeckKeywordConstPtr compdatKeyword );
static std::pair<std::string , std::vector<std::shared_ptr<const Completion> > > completionsFromCOMPDATRecord( DeckRecordConstPtr compdatRecord );
private:
int m_i, m_j, m_k;
@@ -49,8 +50,8 @@ namespace Opm {
CompletionStateEnum m_state;
};
typedef boost::shared_ptr<Completion> CompletionPtr;
typedef boost::shared_ptr<const Completion> CompletionConstPtr;
typedef std::shared_ptr<Completion> CompletionPtr;
typedef std::shared_ptr<const Completion> CompletionConstPtr;
}

6
opm/parser/eclipse/EclipseState/Schedule/CompletionSet.hpp
View File

@@ -21,6 +21,8 @@
#ifndef COMPLETIONSET_HPP_
#define COMPLETIONSET_HPP_
#include <memory>
#include <boost/date_time.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
@@ -41,8 +43,8 @@ namespace Opm {
std::vector<CompletionConstPtr> m_completions;
};
typedef boost::shared_ptr<CompletionSet> CompletionSetPtr;
typedef boost::shared_ptr<const CompletionSet> CompletionSetConstPtr;
typedef std::shared_ptr<CompletionSet> CompletionSetPtr;
typedef std::shared_ptr<const CompletionSet> CompletionSetConstPtr;
}

26
opm/parser/eclipse/EclipseState/Schedule/Group.cpp
View File

@@ -28,12 +28,12 @@ namespace Opm {
struct ProductionData {
ProductionData(TimeMapConstPtr timeMap);
boost::shared_ptr<DynamicState<GroupProduction::ControlEnum> > controlMode;
boost::shared_ptr<DynamicState<GroupProductionExceedLimit::ActionEnum> > exceedAction;
boost::shared_ptr<DynamicState<double> > oilTarget;
boost::shared_ptr<DynamicState<double> > waterTarget;
boost::shared_ptr<DynamicState<double> > gasTarget;
boost::shared_ptr<DynamicState<double> > liquidTarget;
std::shared_ptr<DynamicState<GroupProduction::ControlEnum> > controlMode;
std::shared_ptr<DynamicState<GroupProductionExceedLimit::ActionEnum> > exceedAction;
std::shared_ptr<DynamicState<double> > oilTarget;
std::shared_ptr<DynamicState<double> > waterTarget;
std::shared_ptr<DynamicState<double> > gasTarget;
std::shared_ptr<DynamicState<double> > liquidTarget;
};
@@ -56,13 +56,13 @@ namespace Opm {
struct InjectionData {
InjectionData(TimeMapConstPtr timeMap);
boost::shared_ptr<DynamicState<PhaseEnum> > phase;
boost::shared_ptr<DynamicState<GroupInjection::ControlEnum> > controlMode;
boost::shared_ptr<DynamicState<double> > rate;
boost::shared_ptr<DynamicState<double> > surfaceFlowMaxRate;
boost::shared_ptr<DynamicState<double> > reservoirFlowMaxRate;
boost::shared_ptr<DynamicState<double> > targetReinjectFraction;
boost::shared_ptr<DynamicState<double> > targetVoidReplacementFraction;
std::shared_ptr<DynamicState<PhaseEnum> > phase;
std::shared_ptr<DynamicState<GroupInjection::ControlEnum> > controlMode;
std::shared_ptr<DynamicState<double> > rate;
std::shared_ptr<DynamicState<double> > surfaceFlowMaxRate;
std::shared_ptr<DynamicState<double> > reservoirFlowMaxRate;
std::shared_ptr<DynamicState<double> > targetReinjectFraction;
std::shared_ptr<DynamicState<double> > targetVoidReplacementFraction;
};
InjectionData::InjectionData(TimeMapConstPtr timeMap) :

12
opm/parser/eclipse/EclipseState/Schedule/Group.hpp
View File

@@ -27,7 +27,7 @@
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellSet.hpp>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <string>
namespace Opm {
@@ -96,12 +96,12 @@ namespace Opm {
size_t m_creationTimeStep;
std::string m_name;
boost::shared_ptr<GroupInjection::InjectionData> m_injection;
boost::shared_ptr<GroupProduction::ProductionData> m_production;
boost::shared_ptr<DynamicState<WellSetConstPtr> > m_wells;
std::shared_ptr<GroupInjection::InjectionData> m_injection;
std::shared_ptr<GroupProduction::ProductionData> m_production;
std::shared_ptr<DynamicState<WellSetConstPtr> > m_wells;
};
typedef boost::shared_ptr<Group> GroupPtr;
typedef boost::shared_ptr<const Group> GroupConstPtr;
typedef std::shared_ptr<Group> GroupPtr;
typedef std::shared_ptr<const Group> GroupConstPtr;
}

8
opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp
View File

@@ -24,7 +24,7 @@
#include <string>
#include <map>
#include <boost/shared_ptr.hpp>
#include <memory>
namespace Opm {
@@ -37,7 +37,7 @@ namespace Opm {
GroupTreeNodePtr getNode(const std::string& nodeName) const;
GroupTreeNodePtr getParent(const std::string& childName) const;
boost::shared_ptr<GroupTree> deepCopy() const;
std::shared_ptr<GroupTree> deepCopy() const;
void printTree() const;
@@ -50,8 +50,8 @@ namespace Opm {
void printTree(GroupTreeNodePtr fromNode) const;
};
typedef boost::shared_ptr<GroupTree> GroupTreePtr;
typedef boost::shared_ptr<const GroupTree> GroupTreeConstPtr;
typedef std::shared_ptr<GroupTree> GroupTreePtr;
typedef std::shared_ptr<const GroupTree> GroupTreeConstPtr;
}
#endif /* GROUPTREE_HPP */

6
opm/parser/eclipse/EclipseState/Schedule/GroupTreeNode.cpp
View File

@@ -39,7 +39,7 @@ namespace Opm {
return child;
}
void GroupTreeNode::addChildGroup(boost::shared_ptr<GroupTreeNode> childGroup) {
void GroupTreeNode::addChildGroup(std::shared_ptr<GroupTreeNode> childGroup) {
if (hasChildGroup(childGroup->name())) {
throw std::invalid_argument("Child group with name \"" + childGroup->name() + "\"already exists under node " + m_name);
}
@@ -69,11 +69,11 @@ namespace Opm {
return GroupTreeNodePtr(new GroupTreeNode("FIELD"));
}
std::map<std::string, boost::shared_ptr<GroupTreeNode> >::iterator GroupTreeNode::begin() {
std::map<std::string, std::shared_ptr<GroupTreeNode> >::iterator GroupTreeNode::begin() {
return m_childGroups.begin();
}
std::map<std::string, boost::shared_ptr<GroupTreeNode> >::iterator GroupTreeNode::end() {
std::map<std::string, std::shared_ptr<GroupTreeNode> >::iterator GroupTreeNode::end() {
return m_childGroups.end();
}
}

22
opm/parser/eclipse/EclipseState/Schedule/GroupTreeNode.hpp
View File

@@ -22,7 +22,7 @@
#include <string>
#include <map>
#include <boost/shared_ptr.hpp>
#include <memory>
namespace Opm {
@@ -32,26 +32,26 @@ namespace Opm {
class GroupTreeNode {
public:
const std::string& name() const;
boost::shared_ptr<GroupTreeNode> addChildGroup(const std::string& childName);
void addChildGroup(boost::shared_ptr<GroupTreeNode> childGroup);
std::shared_ptr<GroupTreeNode> addChildGroup(const std::string& childName);
void addChildGroup(std::shared_ptr<GroupTreeNode> childGroup);
bool hasChildGroup(const std::string& childName) const;
void removeChild(boost::shared_ptr<GroupTreeNode> child);
boost::shared_ptr<GroupTreeNode> getChildGroup(const std::string& childName);
void removeChild(std::shared_ptr<GroupTreeNode> child);
std::shared_ptr<GroupTreeNode> getChildGroup(const std::string& childName);
static boost::shared_ptr<GroupTreeNode> createFieldNode();
std::map<std::string, boost::shared_ptr<GroupTreeNode> >::iterator begin();
std::map<std::string, boost::shared_ptr<GroupTreeNode> >::iterator end();
static std::shared_ptr<GroupTreeNode> createFieldNode();
std::map<std::string, std::shared_ptr<GroupTreeNode> >::iterator begin();
std::map<std::string, std::shared_ptr<GroupTreeNode> >::iterator end();
private:
GroupTreeNode(const std::string& name);
std::string m_name;
std::map<std::string, boost::shared_ptr<GroupTreeNode> > m_childGroups;
std::map<std::string, std::shared_ptr<GroupTreeNode> > m_childGroups;
};
typedef boost::shared_ptr<GroupTreeNode> GroupTreeNodePtr;
typedef boost::shared_ptr<const GroupTreeNode> GroupTreeNodeConstPtr;
typedef std::shared_ptr<GroupTreeNode> GroupTreeNodePtr;
typedef std::shared_ptr<const GroupTreeNode> GroupTreeNodeConstPtr;
}
#endif /* GROUPTREENODE_HPP */

5
opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
View File

@@ -25,7 +25,6 @@ namespace Opm {
Schedule::Schedule(DeckConstPtr deck) {
if (deck->hasKeyword("SCHEDULE")) {
addGroup( "FIELD", 0 );
initFromDeck(deck);
} else
throw std::invalid_argument("Deck does not contain SCHEDULE section.\n");
@@ -33,6 +32,7 @@ namespace Opm {
void Schedule::initFromDeck(DeckConstPtr deck) {
createTimeMap(deck);
addGroup( "FIELD", 0 );
initRootGroupTreeNode(getTimeMap());
iterateScheduleSection(deck);
}
@@ -292,6 +292,9 @@ namespace Opm {
}
void Schedule::addGroup(const std::string& groupName, size_t timeStep) {
if (!m_timeMap) {
throw std::invalid_argument("TimeMap is null, can't add group named: " + groupName);
}
GroupPtr group(new Group(groupName, m_timeMap , timeStep));
m_groups[ groupName ] = group;
}

8
opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp
View File

@@ -26,7 +26,7 @@
#include <opm/parser/eclipse/EclipseState/Schedule/Group.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <map>
@@ -54,7 +54,7 @@ namespace Opm
TimeMapPtr m_timeMap;
std::map<std::string , WellPtr> m_wells;
std::map<std::string , GroupPtr> m_groups;
boost::shared_ptr<DynamicState<GroupTreePtr> > m_rootGroupTree;
std::shared_ptr<DynamicState<GroupTreePtr> > m_rootGroupTree;
void addWellToGroup( GroupPtr newGroup , WellPtr well , size_t timeStep);
void initFromDeck(DeckConstPtr deck);
@@ -78,8 +78,8 @@ namespace Opm
void handleGRUPTREE(DeckKeywordConstPtr keyword, size_t currentStep);
};
typedef boost::shared_ptr<Schedule> SchedulePtr;
typedef boost::shared_ptr<const Schedule> ScheduleConstPtr;
typedef std::shared_ptr<Schedule> SchedulePtr;
typedef std::shared_ptr<const Schedule> ScheduleConstPtr;
}
#endif

4
opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp
View File

@@ -45,8 +45,8 @@ namespace Opm {
boost::gregorian::date m_startDate;
std::vector<boost::posix_time::ptime> m_timeList;
};
typedef boost::shared_ptr<TimeMap> TimeMapPtr;
typedef boost::shared_ptr<const TimeMap> TimeMapConstPtr;
typedef std::shared_ptr<TimeMap> TimeMapPtr;
typedef std::shared_ptr<const TimeMap> TimeMapConstPtr;
}

22
opm/parser/eclipse/EclipseState/Schedule/Well.hpp
View File

@@ -26,7 +26,7 @@
#include <opm/parser/eclipse/EclipseState/Schedule/CompletionSet.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Completion.hpp>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <string>
namespace Opm {
@@ -62,18 +62,18 @@ namespace Opm {
size_t m_creationTimeStep;
std::string m_name;
boost::shared_ptr<DynamicState<double> > m_oilRate;
boost::shared_ptr<DynamicState<double> > m_gasRate;
boost::shared_ptr<DynamicState<double> > m_waterRate;
boost::shared_ptr<DynamicState<double> > m_injectionRate;
std::shared_ptr<DynamicState<double> > m_oilRate;
std::shared_ptr<DynamicState<double> > m_gasRate;
std::shared_ptr<DynamicState<double> > m_waterRate;
std::shared_ptr<DynamicState<double> > m_injectionRate;
boost::shared_ptr<DynamicState<bool> > m_inPredictionMode;
boost::shared_ptr<DynamicState<bool> > m_isProducer;
boost::shared_ptr<DynamicState<CompletionSetConstPtr> > m_completions;
boost::shared_ptr<DynamicState<std::string> > m_groupName;
std::shared_ptr<DynamicState<bool> > m_inPredictionMode;
std::shared_ptr<DynamicState<bool> > m_isProducer;
std::shared_ptr<DynamicState<CompletionSetConstPtr> > m_completions;
std::shared_ptr<DynamicState<std::string> > m_groupName;
};
typedef boost::shared_ptr<Well> WellPtr;
typedef boost::shared_ptr<const Well> WellConstPtr;
typedef std::shared_ptr<Well> WellPtr;
typedef std::shared_ptr<const Well> WellConstPtr;
}

6
opm/parser/eclipse/EclipseState/Schedule/WellSet.hpp
View File

@@ -23,7 +23,7 @@
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <string>
#include <map>
@@ -43,8 +43,8 @@ namespace Opm {
std::map<std::string , WellPtr> m_wells;
};
typedef boost::shared_ptr<WellSet> WellSetPtr;
typedef boost::shared_ptr<const WellSet> WellSetConstPtr;
typedef std::shared_ptr<WellSet> WellSetPtr;
typedef std::shared_ptr<const WellSet> WellSetConstPtr;
}
#endif

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

@@ -195,7 +195,7 @@ BOOST_AUTO_TEST_CASE(parse_truncatedrecords_deckFilledWithDefaults) {
ParserKeywordConstPtr parserKeyword = parser->getKeyword("RADFIN4");
ParserRecordConstPtr parserRecord = parserKeyword->getRecord();
ParserItemConstPtr nwmaxItem = parserRecord->get("NWMAX");
ParserIntItemConstPtr intItem = boost::static_pointer_cast<const ParserIntItem>(nwmaxItem);
ParserIntItemConstPtr intItem = std::static_pointer_cast<const ParserIntItem>(nwmaxItem);
BOOST_CHECK_EQUAL(18, radfin4_0_full->getRecord(0)->getItem(10)->getInt(0));
BOOST_CHECK_EQUAL(intItem->getDefault(), radfin4_1_partial->getRecord(0)->getItem(10)->getInt(0));

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

@@ -22,7 +22,7 @@
#include <string>
#include <map>
#include <fstream>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <opm/json/JsonObject.hpp>
@@ -69,8 +69,8 @@ namespace Opm {
void addDefaultKeywords();
};
typedef boost::shared_ptr<Parser> ParserPtr;
typedef boost::shared_ptr<const Parser> ParserConstPtr;
typedef std::shared_ptr<Parser> ParserPtr;
typedef std::shared_ptr<const Parser> ParserConstPtr;
} // namespace Opm
#endif /* PARSER_H */

6
opm/parser/eclipse/Parser/ParserDoubleItem.hpp
View File

@@ -20,6 +20,8 @@
#ifndef PARSERDOUBLEITEM_HPP
#define PARSERDOUBLEITEM_HPP
#include <memory>
#include <opm/json/JsonObject.hpp>
#include <opm/parser/eclipse/Parser/ParserItem.hpp>
@@ -50,8 +52,8 @@ namespace Opm {
double m_default;
};
typedef boost::shared_ptr<const ParserDoubleItem> ParserDoubleItemConstPtr;
typedef boost::shared_ptr<ParserDoubleItem> ParserDoubleItemPtr;
typedef std::shared_ptr<const ParserDoubleItem> ParserDoubleItemConstPtr;
typedef std::shared_ptr<ParserDoubleItem> ParserDoubleItemPtr;
}
#endif /* PARSERINTITEM_HPP */

6
opm/parser/eclipse/Parser/ParserIntItem.hpp
View File

@@ -21,6 +21,8 @@
#ifndef PARSERINTITEM_HPP
#define PARSERINTITEM_HPP
#include <memory>
#include <opm/json/JsonObject.hpp>
#include <opm/parser/eclipse/Parser/ParserItem.hpp>
@@ -52,8 +54,8 @@ namespace Opm {
int m_default;
};
typedef boost::shared_ptr<const ParserIntItem> ParserIntItemConstPtr;
typedef boost::shared_ptr<ParserIntItem> ParserIntItemPtr;
typedef std::shared_ptr<const ParserIntItem> ParserIntItemConstPtr;
typedef std::shared_ptr<ParserIntItem> ParserIntItemPtr;
}
#endif /* PARSERINTITEM_HPP */

6
opm/parser/eclipse/Parser/ParserItem.hpp
View File

@@ -24,7 +24,7 @@
#include <iostream>
#include <deque>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <boost/lexical_cast.hpp>
#include <opm/json/JsonObject.hpp>
@@ -65,8 +65,8 @@ namespace Opm {
ParserItemSizeEnum m_sizeType;
};
typedef boost::shared_ptr<const ParserItem> ParserItemConstPtr;
typedef boost::shared_ptr<ParserItem> ParserItemPtr;
typedef std::shared_ptr<const ParserItem> ParserItemConstPtr;
typedef std::shared_ptr<ParserItem> ParserItemPtr;
}

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

@@ -22,7 +22,7 @@
#include <string>
#include <iostream>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <opm/json/JsonObject.hpp>
#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
@@ -81,8 +81,8 @@ namespace Opm {
void addItems( const Json::JsonObject& jsonConfig);
void addTableItems();
};
typedef boost::shared_ptr<ParserKeyword> ParserKeywordPtr;
typedef boost::shared_ptr<const ParserKeyword> ParserKeywordConstPtr;
typedef std::shared_ptr<ParserKeyword> ParserKeywordPtr;
typedef std::shared_ptr<const ParserKeyword> ParserKeywordConstPtr;
}
#endif

6
opm/parser/eclipse/Parser/ParserRecord.hpp
View File

@@ -22,7 +22,7 @@
#include <vector>
#include <map>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <opm/parser/eclipse/Parser/ParserItem.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
@@ -44,8 +44,8 @@ namespace Opm {
std::map<std::string , ParserItemConstPtr> m_itemMap;
};
typedef boost::shared_ptr<const ParserRecord> ParserRecordConstPtr;
typedef boost::shared_ptr<ParserRecord> ParserRecordPtr;
typedef std::shared_ptr<const ParserRecord> ParserRecordConstPtr;
typedef std::shared_ptr<ParserRecord> ParserRecordPtr;
}

6
opm/parser/eclipse/Parser/ParserStringItem.hpp
View File

@@ -21,6 +21,8 @@
#ifndef PARSERSTRINGITEM_HPP
#define PARSERSTRINGITEM_HPP
#include <memory>
#include <opm/json/JsonObject.hpp>
#include <opm/parser/eclipse/Parser/ParserItem.hpp>
@@ -48,8 +50,8 @@ namespace Opm {
std::string m_default;
};
typedef boost::shared_ptr<const ParserStringItem> ParserStringItemConstPtr;
typedef boost::shared_ptr<ParserStringItem> ParserStringItemPtr;
typedef std::shared_ptr<const ParserStringItem> ParserStringItemConstPtr;
typedef std::shared_ptr<ParserStringItem> ParserStringItemPtr;
}
#endif /* PARSERSTRINGITEM_HPP */

6
opm/parser/eclipse/RawDeck/RawKeyword.hpp
View File

@@ -23,7 +23,7 @@
#include <string>
#include <utility>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <memory>
#include "RawRecord.hpp"
@@ -74,8 +74,8 @@ namespace Opm {
void setKeywordName(const std::string& keyword);
static bool isValidKeyword(const std::string& keywordCandidate);
};
typedef boost::shared_ptr<RawKeyword> RawKeywordPtr;
typedef boost::shared_ptr<const RawKeyword> RawKeywordConstPtr;
typedef std::shared_ptr<RawKeyword> RawKeywordPtr;
typedef std::shared_ptr<const RawKeyword> RawKeywordConstPtr;
}
#endif /* RAWKEYWORD_HPP */

4
opm/parser/eclipse/RawDeck/RawRecord.hpp
View File

@@ -62,8 +62,8 @@ namespace Opm {
bool charIsSeparator(char candidate);
static unsigned int findTerminatingSlash(const std::string& singleRecordString);
};
typedef boost::shared_ptr<RawRecord> RawRecordPtr;
typedef boost::shared_ptr<const RawRecord> RawRecordConstPtr;
typedef std::shared_ptr<RawRecord> RawRecordPtr;
typedef std::shared_ptr<const RawRecord> RawRecordConstPtr;
}