changed: refactorize Equil class into a container template over a record type

make Equil a type alias for EquilContainer<EquilRecord>

opm/input/eclipse/EclipseState/InitConfig/Equil.hpp

@@ -64,16 +64,17 @@ namespace Opm {
             bool humid_gas_init_proc = false;
     };
 
-    class Equil {
+    template<class RecordType>
+    class EquilContainer {
         public:
-            using const_iterator = std::vector< EquilRecord >::const_iterator;
+            using const_iterator = typename std::vector<RecordType>::const_iterator;
 
-            Equil() = default;
-            explicit Equil( const DeckKeyword& );
+            EquilContainer() = default;
+            explicit EquilContainer( const DeckKeyword& );
 
-            static Equil serializationTestObject();
+            static EquilContainer serializationTestObject();
 
-            const EquilRecord& getRecord( size_t id ) const;
+            const RecordType& getRecord(std::size_t id) const;
 
             size_t size() const;
             bool empty() const;
@@ -81,7 +82,7 @@ namespace Opm {
             const_iterator begin() const;
             const_iterator end() const;
 
-            bool operator==(const Equil& data) const;
+            bool operator==(const EquilContainer& data) const;
 
             template<class Serializer>
             void serializeOp(Serializer& serializer)
@@ -90,9 +91,10 @@ namespace Opm {
             }
 
         private:
-            std::vector< EquilRecord > m_records;
+            std::vector<RecordType> m_records;
     };
 
+    using Equil = EquilContainer<EquilRecord>;
 }
 
 #endif //OPM_EQUIL_HPP

src/opm/input/eclipse/EclipseState/InitConfig/Equil.cpp

@@ -102,7 +102,8 @@ namespace Opm {
 
     /* ----------------------------------------------------------------- */
 
-    Equil::Equil( const DeckKeyword& keyword )
+    template<class RecordType>
+    EquilContainer<RecordType>::EquilContainer(const DeckKeyword& keyword)
     {
         using ParserKeywords::EQUIL;
 
@@ -111,35 +112,47 @@ namespace Opm {
         }
     }
 
-    Equil Equil::serializationTestObject()
+    template<class RecordType>
+    EquilContainer<RecordType> EquilContainer<RecordType>::serializationTestObject()
     {
-        Equil result;
-        result.m_records = {EquilRecord::serializationTestObject()};
+        EquilContainer<RecordType> result;
+        result.m_records = {RecordType::serializationTestObject()};
 
         return result;
     }
 
-    const EquilRecord& Equil::getRecord( size_t id ) const {
+    template<class RecordType>
+    const RecordType& EquilContainer<RecordType>::getRecord(std::size_t id) const {
         return this->m_records.at( id );
     }
 
-    size_t Equil::size() const {
+    template<class RecordType>
+    std::size_t EquilContainer<RecordType>::size() const {
         return this->m_records.size();
     }
 
-    bool Equil::empty() const {
+    template<class RecordType>
+    bool EquilContainer<RecordType>::empty() const {
         return this->m_records.empty();
     }
 
-    Equil::const_iterator Equil::begin() const {
+    template<class RecordType>
+    typename EquilContainer<RecordType>::const_iterator
+    EquilContainer<RecordType>::begin() const {
         return this->m_records.begin();
     }
 
-    Equil::const_iterator Equil::end() const {
+    template<class RecordType>
+    typename EquilContainer<RecordType>::const_iterator
+    EquilContainer<RecordType>::end() const {
         return this->m_records.end();
     }
 
-    bool Equil::operator==(const Equil& data) const {
+    template<class RecordType>
+    bool EquilContainer<RecordType>::
+    operator==(const EquilContainer<RecordType>& data) const {
         return this->m_records == data.m_records;
     }
+
+    template class EquilContainer<EquilRecord>;
 }