Merge pull request #3148 from akva2/serializer_simplify

changed: only use operator() for the serializer

opm/common/utility/TimeService.hpp

@@ -104,7 +104,7 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            ymd_.serializeOp(serializer);
+            serializer(ymd_);
             serializer(hour_);
             serializer(minutes_);
             serializer(seconds_);

opm/input/eclipse/Deck/Deck.hpp

@@ -116,8 +116,8 @@ namespace Opm {
             template<class Serializer>
             void serializeOp(Serializer& serializer)
             {
-                serializer.vector(keywordList);
-                defaultUnits.serializeOp(serializer);
+                serializer(keywordList);
+                serializer(defaultUnits);
                 serializer(activeUnits);
                 serializer(m_dataFile);
                 serializer(input_path);

opm/input/eclipse/Deck/DeckItem.hpp

@@ -140,14 +140,14 @@ namespace Opm {
             serializer(dval);
             serializer(ival);
             serializer(sval);
-            serializer.vector(rsval);
-            serializer.vector(uval);
+            serializer(rsval);
+            serializer(uval);
             serializer(type);
             serializer(item_name);
-            serializer.vector(value_status);
+            serializer(value_status);
             serializer(raw_data);
-            serializer.vector(active_dimensions);
-            serializer.vector(default_dimensions);
+            serializer(active_dimensions);
+            serializer(default_dimensions);
         }
 
         void reserve_additionalRawString(std::size_t);

opm/input/eclipse/Deck/DeckKeyword.hpp

@@ -97,8 +97,8 @@ namespace Opm {
         void serializeOp(Serializer& serializer)
         {
             serializer(m_keywordName);
-            m_location.serializeOp(serializer);
-            serializer.vector(m_recordList);
+            serializer(m_location);
+            serializer(m_recordList);
             serializer(m_isDataKeyword);
             serializer(m_slashTerminated);
             serializer(m_isDoubleRecordKeyword);

opm/input/eclipse/Deck/DeckRecord.hpp

@@ -75,7 +75,7 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            serializer.vector(m_items);
+            serializer(m_items);
         }
 
     private:

opm/input/eclipse/Deck/UDAValue.hpp

@@ -88,7 +88,7 @@ public:
         serializer(numeric_value);
         serializer(double_value);
         serializer(string_value);
-        dim.serializeOp(serializer);
+        serializer(dim);
     }
 
     void operator*=(double rhs);

opm/input/eclipse/EclipseState/Aquifer/Aquancon.hpp

@@ -105,7 +105,7 @@ namespace Opm {
             template<class Serializer>
             void serializeOp(Serializer& serializer)
             {
-                serializer.map(this->cells);
+                serializer(this->cells);
             }
 
         private:

opm/input/eclipse/EclipseState/Aquifer/AquiferCT.hpp

@@ -142,7 +142,7 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            serializer.vector(m_aquct);
+            serializer(m_aquct);
         }
 
     private:

opm/input/eclipse/EclipseState/Aquifer/AquiferConfig.hpp

@@ -71,10 +71,10 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        aquifetp.serializeOp(serializer);
-        aquiferct.serializeOp(serializer);
-        aqconn.serializeOp(serializer);
-        numerical_aquifers.serializeOp(serializer);
+        serializer(aquifetp);
+        serializer(aquiferct);
+        serializer(aqconn);
+        serializer(numerical_aquifers);
     }
 
 private:

opm/input/eclipse/EclipseState/Aquifer/Aquifetp.hpp

@@ -124,7 +124,7 @@ class Aquifetp {
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.vector(m_aqufetp);
+        serializer(m_aqufetp);
     }
 
 private:

opm/input/eclipse/EclipseState/Aquifer/NumericalAquifer/NumericalAquifers.hpp

@@ -61,7 +61,7 @@ namespace Opm {
         template <class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            serializer.map(this->m_aquifers);
+            serializer(this->m_aquifers);
             serializer(this->m_num_records);
         }
 

opm/input/eclipse/EclipseState/Aquifer/NumericalAquifer/SingleNumericalAquifer.hpp

@@ -69,8 +69,8 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer) {
             serializer(this->id_);
-            serializer.vector(this->cells_);
-            serializer.vector(this->connections_);
+            serializer(this->cells_);
+            serializer(this->connections_);
         }
 
         private:

opm/input/eclipse/EclipseState/EclipseConfig.hpp

@@ -46,8 +46,8 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            m_initConfig.serializeOp(serializer);
-            io_config.serializeOp(serializer);
+            serializer(m_initConfig);
+            serializer(io_config);
         }
 
     private:

opm/input/eclipse/EclipseState/EclipseState.hpp

@@ -118,19 +118,19 @@ namespace Opm {
         {
             // FieldPropsManager is handled through a different mechanism.
             // Do not add the member (i.e., field_props) to this list.
-            m_tables.serializeOp(serializer);
-            m_runspec.serializeOp(serializer);
-            m_eclipseConfig.serializeOp(serializer);
-            m_deckUnitSystem.serializeOp(serializer);
-            m_inputNnc.serializeOp(serializer);
-            m_gridDims.serializeOp(serializer);
-            m_simulationConfig.serializeOp(serializer);
-            aquifer_config.serializeOp(serializer);
-            m_transMult.serializeOp(serializer);
-            m_faults.serializeOp(serializer);
+            serializer(m_tables);
+            serializer(m_runspec);
+            serializer(m_eclipseConfig);
+            serializer(m_deckUnitSystem);
+            serializer(m_inputNnc);
+            serializer(m_gridDims);
+            serializer(m_simulationConfig);
+            serializer(aquifer_config);
+            serializer(m_transMult);
+            serializer(m_faults);
             serializer(m_title);
-            tracer_config.serializeOp(serializer);
-            m_micppara.serializeOp(serializer);
+            serializer(tracer_config);
+            serializer(m_micppara);
         }
 
         static bool rst_cmp(const EclipseState& full_state, const EclipseState& rst_state);

opm/input/eclipse/EclipseState/Grid/Fault.hpp

@@ -52,7 +52,7 @@ public:
     {
         serializer(m_name);
         serializer(m_transMult);
-        serializer.vector(m_faceList);
+        serializer(m_faceList);
     }
 
 private:

opm/input/eclipse/EclipseState/Grid/FaultCollection.hpp

@@ -55,7 +55,7 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        m_faults.serializeOp(serializer);
+        serializer(m_faults);
     }
 
 private:

opm/input/eclipse/EclipseState/Grid/MULTREGTScanner.hpp

@@ -105,7 +105,7 @@ namespace Opm {
             serializer(nx);
             serializer(ny);
             serializer(nz);
-            serializer.vector(m_records);
+            serializer(m_records);
             ExternalSearchMap searchMap = getSearchMap();
             serializer(searchMap);
             if (m_searchMap.empty())

opm/input/eclipse/EclipseState/Grid/NNC.hpp

@@ -120,8 +120,8 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.vector(m_input);
-        serializer.vector(m_edit);
+        serializer(m_input);
+        serializer(m_edit);
         serializer(m_nnc_location);
         serializer(m_edit_location);
     }

opm/input/eclipse/EclipseState/Grid/TranCalculator.hpp

@@ -102,7 +102,7 @@ public:
     void serializeOp(Serializer& serializer)
     {
         serializer(m_name);
-        serializer.vector(actions);
+        serializer(actions);
     }
 
     static TranCalculator serializeObject()

opm/input/eclipse/EclipseState/Grid/TransMult.hpp

@@ -67,10 +67,9 @@ namespace Opm {
             serializer(m_nx);
             serializer(m_ny);
             serializer(m_nz);
-            // map used to avoid explicit instances with FaceDir::DirEnum in serializer
-            serializer.map(m_trans);
-            serializer.map(m_names);
-            m_multregtScanner.serializeOp(serializer);
+            serializer(m_trans);
+            serializer(m_names);
+            serializer(m_multregtScanner);
         }
 
     private:

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

@@ -77,7 +77,7 @@ namespace Opm {
             template<class Serializer>
             void serializeOp(Serializer& serializer)
             {
-                serializer.vector(m_records);
+                serializer(m_records);
             }
 
         private:

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

@@ -99,7 +99,7 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.vector(data_);
+        serializer(data_);
         serializer(transport_phase_);
         serializer(mobility_model_);
     }

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

@@ -63,8 +63,8 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            equil.serializeOp(serializer);
-            foamconfig.serializeOp(serializer);
+            serializer(equil);
+            serializer(foamconfig);
             serializer(m_filleps);
             serializer(m_gravity);
             serializer(m_restartRequested);

opm/input/eclipse/EclipseState/Runspec.hpp

@@ -70,13 +70,7 @@ class Phases {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            if (serializer.isSerializing())
-                serializer(bits.to_ulong());
-            else {
-              unsigned long Bits = 0;
-              serializer(Bits);
-              bits = std::bitset<NUM_PHASES_IN_ENUM>(Bits);
-            }
+            serializer(bits);
         }
 
     private:
@@ -469,19 +463,19 @@ public:
     void serializeOp(Serializer& serializer)
     {
         serializer(this->m_start_time);
-        active_phases.serializeOp(serializer);
-        m_tabdims.serializeOp(serializer);
-        m_regdims.serializeOp(serializer);
-        endscale.serializeOp(serializer);
-        welldims.serializeOp(serializer);
-        wsegdims.serializeOp(serializer);
-        netwrkdims.serializeOp(serializer);
-        aquiferdims.serializeOp(serializer);
-        udq_params.serializeOp(serializer);
-        hystpar.serializeOp(serializer);
-        m_actdims.serializeOp(serializer);
-        m_sfuncctrl.serializeOp(serializer);
-        m_nupcol.serializeOp(serializer);
+        serializer(active_phases);
+        serializer(m_tabdims);
+        serializer(m_regdims);
+        serializer(endscale);
+        serializer(welldims);
+        serializer(wsegdims);
+        serializer(netwrkdims);
+        serializer(aquiferdims);
+        serializer(udq_params);
+        serializer(hystpar);
+        serializer(m_actdims);
+        serializer(m_sfuncctrl);
+        serializer(m_nupcol);
         serializer(m_co2storage);
         serializer(m_micp);
     }

opm/input/eclipse/EclipseState/SimulationConfig/BCConfig.hpp

@@ -95,7 +95,7 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.vector(m_faces);
+        serializer(m_faces);
     }
 
 private:

opm/input/eclipse/EclipseState/SimulationConfig/RockConfig.hpp

@@ -76,7 +76,7 @@ struct RockComp {
     void serializeOp(Serializer& serializer)
     {
         serializer(m_active);
-        serializer.vector(m_comp);
+        serializer(m_comp);
         serializer(num_property);
         serializer(num_tables);
         serializer(m_water_compaction);

opm/input/eclipse/EclipseState/SimulationConfig/SimulationConfig.hpp

@@ -58,9 +58,9 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            m_ThresholdPressure.serializeOp(serializer);
-            m_bcconfig.serializeOp(serializer);
-            m_rock_config.serializeOp(serializer);
+            serializer(m_ThresholdPressure);
+            serializer(m_bcconfig);
+            serializer(m_rock_config);
             serializer(m_useCPR);
             serializer(m_DISGAS);
             serializer(m_VAPOIL);

opm/input/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp

@@ -76,7 +76,7 @@ namespace Opm {
         {
             serializer(keyword_);
             serializer(category_);
-            loc.serializeOp(serializer);
+            serializer(loc);
             serializer(type_);
             serializer(name_);
             serializer(number_);
@@ -206,7 +206,7 @@ namespace Opm {
             template<class Serializer>
             void serializeOp(Serializer& serializer)
             {
-               serializer.vector(m_keywords);
+               serializer(m_keywords);
                serializer(short_keywords);
                serializer(summary_keywords);
             }

opm/input/eclipse/EclipseState/Tables/DenT.hpp

@@ -61,7 +61,7 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            serializer.vector(m_records);
+            serializer(m_records);
         }
 
     private:

opm/input/eclipse/EclipseState/Tables/FlatTable.hpp

@@ -21,7 +21,7 @@ struct FlatTable : public std::vector< T > {
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.vector(*this);
+        serializer(static_cast<std::vector<T>&>(*this));
     }
 };
 
@@ -57,7 +57,7 @@ public:
     template <class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.vector(this->table_);
+        serializer(this->table_);
     }
 
 protected:

opm/input/eclipse/EclipseState/Tables/JouleThomson.hpp

@@ -59,7 +59,7 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            serializer.vector(m_records);
+            serializer(m_records);
         }
 
     private:

opm/input/eclipse/EclipseState/Tables/PvtxTable.hpp

@@ -139,12 +139,12 @@ The first row actually corresponds to saturated values.
         template <class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            m_outerColumnSchema.serializeOp(serializer);
-            m_outerColumn.serializeOp(serializer);
-            m_underSaturatedSchema.serializeOp(serializer);
-            m_saturatedSchema.serializeOp(serializer);
-            serializer.vector(m_underSaturatedTables);
-            m_saturatedTable.serializeOp(serializer);
+            serializer(m_outerColumnSchema);
+            serializer(m_outerColumn);
+            serializer(m_underSaturatedSchema);
+            serializer(m_saturatedSchema);
+            serializer(m_underSaturatedTables);
+            serializer(m_saturatedTable);
         }
 
     protected:

opm/input/eclipse/EclipseState/Tables/SimpleTable.hpp

@@ -77,8 +77,8 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            m_schema.serializeOp(serializer);
-            m_columns.serializeOp(serializer);
+            serializer(m_schema);
+            serializer(m_columns);
             serializer(m_jfunc);
         }
 

opm/input/eclipse/EclipseState/Tables/TLMixpar.hpp

@@ -69,7 +69,7 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.vector(data);
+        serializer(data);
     }
 
 private:

opm/input/eclipse/EclipseState/Tables/TableColumn.hpp

@@ -72,7 +72,7 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            m_schema.serializeOp(serializer);
+            serializer(m_schema);
             serializer(m_name);
             serializer(m_values);
             serializer(m_default);

opm/input/eclipse/EclipseState/Tables/TableContainer.hpp

@@ -99,7 +99,7 @@ namespace Opm {
         void serializeOp(Serializer& serializer)
         {
             serializer(m_maxTables);
-            serializer.map(m_tables);
+            serializer(m_tables);
         }
 
     private:

opm/input/eclipse/EclipseState/Tables/TableManager.hpp

@@ -201,58 +201,58 @@ namespace Opm {
         {
             auto simpleTables = m_simpleTables;
             auto split = splitSimpleTable(simpleTables);
-            serializer.map(simpleTables);
+            serializer(simpleTables);
             serializer(split.plyshMax);
-            serializer.map(split.plyshMap);
+            serializer(split.plyshMap);
             serializer(split.rockMax);
-            serializer.map(split.rockMap);
-            serializer.vector(m_pvtgTables);
-            serializer.vector(m_pvtgwTables);
-            serializer.vector(m_pvtgwoTables);
-            serializer.vector(m_pvtoTables);
-            serializer.vector(m_pvtsolTables);
-            serializer.vector(m_rock2dTables);
-            serializer.vector(m_rock2dtrTables);
-            m_pvtwTable.serializeOp(serializer);
-            m_pvcdoTable.serializeOp(serializer);
-            m_densityTable.serializeOp(serializer);
-            m_diffCoeffTable.serializeOp(serializer);
-            m_plyvmhTable.serializeOp(serializer);
-            m_rockTable.serializeOp(serializer);
-            m_plmixparTable.serializeOp(serializer);
-            m_shrateTable.serializeOp(serializer);
-            m_stone1exTable.serializeOp(serializer);
-            m_viscrefTable.serializeOp(serializer);
-            m_watdentTable.serializeOp(serializer);
-            m_sgofletTable.serializeOp(serializer);
-            m_swofletTable.serializeOp(serializer);
-            serializer.vector(m_pvtwsaltTables);
-            serializer.vector(m_rwgsaltTables);
-            serializer.vector(m_bdensityTables);
-            serializer.vector(m_sdensityTables);
-            serializer.map(m_plymwinjTables);
-            serializer.map(m_skprwatTables);
-            serializer.map(m_skprpolyTables);
-            m_tabdims.serializeOp(serializer);
-            m_regdims.serializeOp(serializer);
-            m_eqldims.serializeOp(serializer);
-            m_aqudims.serializeOp(serializer);
+            serializer(split.rockMap);
+            serializer(m_pvtgTables);
+            serializer(m_pvtgwTables);
+            serializer(m_pvtgwoTables);
+            serializer(m_pvtoTables);
+            serializer(m_pvtsolTables);
+            serializer(m_rock2dTables);
+            serializer(m_rock2dtrTables);
+            serializer(m_pvtwTable);
+            serializer(m_pvcdoTable);
+            serializer(m_densityTable);
+            serializer(m_diffCoeffTable);
+            serializer(m_plyvmhTable);
+            serializer(m_rockTable);
+            serializer(m_plmixparTable);
+            serializer(m_shrateTable);
+            serializer(m_stone1exTable);
+            serializer(m_viscrefTable);
+            serializer(m_watdentTable);
+            serializer(m_sgofletTable);
+            serializer(m_swofletTable);
+            serializer(m_pvtwsaltTables);
+            serializer(m_rwgsaltTables);
+            serializer(m_bdensityTables);
+            serializer(m_sdensityTables);
+            serializer(m_plymwinjTables);
+            serializer(m_skprwatTables);
+            serializer(m_skprpolyTables);
+            serializer(m_tabdims);
+            serializer(m_regdims);
+            serializer(m_eqldims);
+            serializer(m_aqudims);
             serializer(hasImptvd);
             serializer(hasEnptvd);
             serializer(hasEqlnum);
             serializer(hasShrate);
             serializer(jfunc);
-            oilDenT.serializeOp(serializer);
-            gasDenT.serializeOp(serializer);
-            watDenT.serializeOp(serializer);
-            oilJT.serializeOp(serializer);
-            gasJT.serializeOp(serializer);
-            watJT.serializeOp(serializer);
-            stcond.serializeOp(serializer);
+            serializer(oilDenT);
+            serializer(gasDenT);
+            serializer(watDenT);
+            serializer(oilJT);
+            serializer(gasJT);
+            serializer(watJT);
+            serializer(stcond);
             serializer(m_gas_comp_index);
             serializer(m_rtemp);
             serializer(m_salinity);
-            m_tlmixpar.serializeOp(serializer);
+            serializer(m_tlmixpar);
             if (!serializer.isSerializing()) {
                 m_simpleTables = simpleTables;
                 if (split.plyshMax > 0) {

opm/input/eclipse/EclipseState/Tables/TableSchema.hpp

@@ -45,7 +45,7 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            m_columns.serializeOp(serializer);
+            serializer(m_columns);
         }
 
     private:

opm/input/eclipse/EclipseState/TracerConfig.hpp

@@ -123,7 +123,7 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.vector(tracers);
+        serializer(tracers);
     }
 
     bool operator==(const TracerConfig& data) const;

opm/input/eclipse/EclipseState/Util/OrderedMap.hpp

@@ -307,7 +307,7 @@ public:
     void serializeOp(Serializer& serializer)
     {
         serializer(m_map);
-        serializer.vector(m_vector);
+        serializer(m_vector);
     }
 };
 }

opm/input/eclipse/Schedule/Action/ASTNode.hpp

@@ -43,7 +43,7 @@ public:
         serializer(func);
         serializer(arg_list);
         serializer(number);
-        serializer.vector(children);
+        serializer(children);
     }
 
 private:

opm/input/eclipse/Schedule/Action/ActionResult.hpp

@@ -85,7 +85,7 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.set(this->well_set);
+        serializer(this->well_set);
     }
 
     static WellSet serializeObject();

opm/input/eclipse/Schedule/Action/ActionX.hpp

@@ -114,9 +114,9 @@ public:
         serializer(m_min_wait);
         serializer(m_start_time);
         serializer(m_id);
-        serializer.vector(keywords);
-        condition.serializeOp(serializer);
-        serializer.vector(m_conditions);
+        serializer(keywords);
+        serializer(condition);
+        serializer(m_conditions);
     }
 
 private:

opm/input/eclipse/Schedule/Action/Actions.hpp

@@ -66,8 +66,8 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.vector(actions);
-        serializer.vector(pyactions);
+        serializer(actions);
+        serializer(pyactions);
     }
 
 private:

opm/input/eclipse/Schedule/Action/Condition.hpp

@@ -88,8 +88,8 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        lhs.serializeOp(serializer);
-        rhs.serializeOp(serializer);
+        serializer(lhs);
+        serializer(rhs);
         serializer(logic);
         serializer(cmp);
         serializer(cmp_string);

opm/input/eclipse/Schedule/Action/State.hpp

@@ -91,9 +91,9 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.map(this->run_state);
-        serializer.map(this->last_result);
-        serializer.map(this->m_python_result);
+        serializer(this->run_state);
+        serializer(this->last_result);
+        serializer(this->m_python_result);
     }
 
 

opm/input/eclipse/Schedule/CompletedCells.hpp

@@ -107,7 +107,7 @@ public:
             serializer(this->k);
             serializer(this->depth);
             serializer(this->props);
-            serializer.array(this->dimensions);
+            serializer(this->dimensions);
         }
 
         Cell(std::size_t g, std::size_t i_, std::size_t j_, std::size_t k_)
@@ -132,8 +132,8 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        this->dims.serializeOp(serializer);
-        serializer.map(this->cells);
+        serializer(this->dims);
+        serializer(this->cells);
     }
 
 private:

opm/input/eclipse/Schedule/Events.hpp

@@ -183,7 +183,7 @@ namespace Opm
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            serializer.map(m_wellgroup_events);
+            serializer(m_wellgroup_events);
         }
     private:
         std::unordered_map<std::string, Events> m_wellgroup_events;

opm/input/eclipse/Schedule/GasLiftOpt.hpp

@@ -279,8 +279,8 @@ public:
         serializer(m_min_eco_gradient);
         serializer(m_min_wait);
         serializer(m_all_newton);
-        serializer.map(m_groups);
-        serializer.map(m_wells);
+        serializer(m_groups);
+        serializer(m_wells);
     }
 private:
     double m_increment = 0;

opm/input/eclipse/Schedule/Group/GConSale.hpp

@@ -57,12 +57,12 @@ namespace Opm {
             template<class Serializer>
             void serializeOp(Serializer& serializer)
             {
-                sales_target.serializeOp(serializer);
-                max_sales_rate.serializeOp(serializer);
-                min_sales_rate.serializeOp(serializer);
+                serializer(sales_target);
+                serializer(max_sales_rate);
+                serializer(min_sales_rate);
                 serializer(max_proc);
                 serializer(udq_undefined);
-                unit_system.serializeOp(serializer);
+                serializer(unit_system);
             }
         };
 
@@ -87,7 +87,7 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            serializer.map(groups);
+            serializer(groups);
         }
 
     private:

opm/input/eclipse/Schedule/Group/GConSump.hpp

@@ -50,11 +50,11 @@ namespace Opm {
             template<class Serializer>
             void serializeOp(Serializer& serializer)
             {
-                consumption_rate.serializeOp(serializer);
-                import_rate.serializeOp(serializer);
+                serializer(consumption_rate);
+                serializer(import_rate);
                 serializer(network_node);
                 serializer(udq_undefined);
-                unit_system.serializeOp(serializer);
+                serializer(unit_system);
             }
         };
 
@@ -77,7 +77,7 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            serializer.map(groups);
+            serializer(groups);
         }
 
     private:

opm/input/eclipse/Schedule/Group/Group.hpp

@@ -161,10 +161,10 @@ struct GroupInjectionProperties {
         serializer(this->name);
         serializer(phase);
         serializer(cmode);
-        surface_max_rate.serializeOp(serializer);
-        resv_max_rate.serializeOp(serializer);
-        target_reinj_fraction.serializeOp(serializer);
-        target_void_fraction.serializeOp(serializer);
+        serializer(surface_max_rate);
+        serializer(resv_max_rate);
+        serializer(target_reinj_fraction);
+        serializer(target_void_fraction);
         serializer(reinj_group);
         serializer(voidage_group);
         serializer(injection_controls);
@@ -217,10 +217,10 @@ struct GroupProductionProperties {
         serializer(name);
         serializer(cmode);
         serializer(exceed_action);
-        oil_target.serializeOp(serializer);
-        water_target.serializeOp(serializer);
-        gas_target.serializeOp(serializer);
-        liquid_target.serializeOp(serializer);
+        serializer(oil_target);
+        serializer(water_target);
+        serializer(gas_target);
+        serializer(liquid_target);
         serializer(guide_rate);
         serializer(guide_rate_def);
         serializer(resv_target);
@@ -313,16 +313,16 @@ struct ProductionControls {
         serializer(m_name);
         serializer(m_insert_index);
         serializer(udq_undefined);
-        unit_system.serializeOp(serializer);
+        serializer(unit_system);
         serializer(group_type);
         serializer(gefac);
         serializer(transfer_gefac);
         serializer(vfp_table);
         serializer(parent_group);
-        m_wells.serializeOp(serializer);
-        m_groups.serializeOp(serializer);
-        serializer.map(injection_properties);
-        production_properties.serializeOp(serializer);
+        serializer(m_wells);
+        serializer(m_groups);
+        serializer(injection_properties);
+        serializer(production_properties);
         serializer(m_topup_phase);
         serializer(m_gpmaint);
     }

opm/input/eclipse/Schedule/Group/GuideRateConfig.hpp

@@ -111,9 +111,9 @@ struct GroupInjTarget {
     void serializeOp(Serializer& serializer)
     {
         serializer(m_model);
-        serializer.map(wells);
-        serializer.map(production_groups);
-        serializer.map(injection_groups);
+        serializer(wells);
+        serializer(production_groups);
+        serializer(injection_groups);
     }
 
 private:

opm/input/eclipse/Schedule/Group/GuideRateModel.hpp

@@ -102,9 +102,9 @@ public:
         serializer(damping_factor_);
         serializer(use_free_gas);
         serializer(default_model);
-        alpha.serializeOp(serializer);
-        beta.serializeOp(serializer);
-        gamma.serializeOp(serializer);
+        serializer(alpha);
+        serializer(beta);
+        serializer(gamma);
     }
 
 private:

opm/input/eclipse/Schedule/MSW/WellSegments.hpp

@@ -111,7 +111,7 @@ namespace Opm {
         void serializeOp(Serializer& serializer)
         {
             serializer(m_comp_pressure_drop);
-            serializer.vector(m_segments);
+            serializer(m_segments);
             serializer(segment_number_to_index);
         }
 

opm/input/eclipse/Schedule/Network/ExtNetwork.hpp

@@ -55,9 +55,9 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.vector(m_branches);
+        serializer(m_branches);
         serializer(insert_indexed_node_names);
-        serializer.map(m_nodes);
+        serializer(m_nodes);
     }
 
 private:

opm/input/eclipse/Schedule/RFTConfig.hpp

@@ -71,9 +71,9 @@ public:
     void serializeOp(Serializer& serializer)
     {
         serializer(first_open_rft);
-        serializer.map(rft_state);
-        serializer.map(plt_state);
-        serializer.map(open_wells);
+        serializer(rft_state);
+        serializer(plt_state);
+        serializer(open_wells);
     }
 
 private:

opm/input/eclipse/Schedule/RPTConfig.hpp

@@ -36,7 +36,7 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.map(m_mnemonics);
+        serializer(m_mnemonics);
     }
 
     std::unordered_map<std::string, unsigned>::const_iterator begin() const { return this->m_mnemonics.begin(); };

opm/input/eclipse/Schedule/RSTConfig.hpp

@@ -205,7 +205,7 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer) {
         serializer(write_rst_file);
-        serializer.map(keywords);
+        serializer(keywords);
         serializer(basic);
         serializer(freq);
         serializer(save);

opm/input/eclipse/Schedule/Schedule.hpp

@@ -99,13 +99,13 @@ namespace Opm
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            m_deck_message_limits.serializeOp(serializer);
-            this->rst_info.serializeOp(serializer);
-            m_runspec.serializeOp(serializer);
-            m_unit_system.serializeOp(serializer);
+            serializer(m_deck_message_limits);
+            serializer(this->rst_info);
+            serializer(m_runspec);
+            serializer(m_unit_system);
             serializer(this->m_input_path);
-            rst_info.serializeOp(serializer);
-            rst_config.serializeOp(serializer);
+            serializer(rst_info);
+            serializer(rst_config);
             serializer(this->output_interval);
             serializer(this->gaslift_opt_active);
         }
@@ -321,13 +321,13 @@ namespace Opm
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            this->m_static.serializeOp(serializer);
-            this->m_sched_deck.serializeOp(serializer);
-            this->action_wgnames.serializeOp(serializer);
+            serializer(this->m_static);
+            serializer(this->m_sched_deck);
+            serializer(this->action_wgnames);
             serializer(this->exit_status);
-            serializer.vector(this->snapshots);
-            this->restart_output.serializeOp(serializer);
-            this->completed_cells.serializeOp(serializer);
+            serializer(this->snapshots);
+            serializer(this->restart_output);
+            serializer(this->completed_cells);
 
             this->template pack_unpack<PAvg>(serializer);
             this->template pack_unpack<WellTestConfig>(serializer);
@@ -361,8 +361,8 @@ namespace Opm
             if (serializer.isSerializing())
                 this->template pack_state<T>(value_list, index_list);
 
-            serializer.vector(value_list);
-            serializer.vector(index_list);
+            serializer(value_list);
+            serializer(index_list);
 
             if (!serializer.isSerializing())
                 this->template unpack_state<T>(value_list, index_list);
@@ -419,7 +419,7 @@ namespace Opm
             if (serializer.isSerializing())
                 pack_map<K,T>(value_list, index_list);
 
-            serializer.vector(value_list);
+            serializer(value_list);
             serializer(index_list);
 
             if (!serializer.isSerializing())

opm/input/eclipse/Schedule/ScheduleDeck.hpp

@@ -74,8 +74,8 @@ namespace Opm {
             serializer(m_time_type);
             serializer(m_start_time);
             serializer(m_end_time);
-            serializer.vector(m_keywords);
-            m_location.serializeOp(serializer);
+            serializer(m_keywords);
+            serializer(m_location);
         }
 
         void dump_time(time_point current_time, DeckOutput& output) const;
@@ -143,8 +143,8 @@ namespace Opm {
             serializer(m_restart_time);
             serializer(m_restart_offset);
             serializer(skiprest);
-            serializer.vector(m_blocks);
-            m_location.serializeOp(serializer);
+            serializer(m_blocks);
+            serializer(m_location);
         }
 
         void dump_deck(std::ostream& os) const;

opm/input/eclipse/Schedule/ScheduleState.hpp

@@ -486,15 +486,15 @@ namespace Opm {
             serializer(m_sumthin);
             serializer(this->m_rptonly);
             serializer(this->next_tstep);
-            m_tuning.serializeOp(serializer);
-            m_nupcol.serializeOp(serializer);
-            m_oilvap.serializeOp(serializer);
-            m_events.serializeOp(serializer);
-            m_wellgroup_events.serializeOp(serializer);
-            serializer.vector(m_geo_keywords);
-            m_message_limits.serializeOp(serializer);
+            serializer(m_tuning);
+            serializer(m_nupcol);
+            serializer(m_oilvap);
+            serializer(m_events);
+            serializer(m_wellgroup_events);
+            serializer(m_geo_keywords);
+            serializer(m_message_limits);
             serializer(m_whistctl_mode);
-            serializer.map(target_wellpi);
+            serializer(target_wellpi);
         }
 
 

opm/input/eclipse/Schedule/SummaryState.hpp

@@ -130,14 +130,14 @@ public:
     {
       serializer(sim_start);
       serializer(elapsed);
-      serializer.map(values);
-      serializer.map(well_values);
-      serializer.set(m_wells);
+      serializer(values);
+      serializer(well_values);
+      serializer(m_wells);
       serializer(well_names);
-      serializer.map(group_values);
-      serializer.set(m_groups);
+      serializer(group_values);
+      serializer(m_groups);
       serializer(group_names);
-      serializer.map(conn_values);
+      serializer(conn_values);
     }
 
     static SummaryState serializeObject()

opm/input/eclipse/Schedule/UDQ/UDQActive.hpp

@@ -178,8 +178,8 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.vector(input_data);
-        serializer.vector(output_data);
+        serializer(input_data);
+        serializer(output_data);
     }
 
 private:

opm/input/eclipse/Schedule/UDQ/UDQAssign.hpp

@@ -111,7 +111,7 @@ public:
     {
         serializer(m_keyword);
         serializer(m_var_type);
-        serializer.vector(records);
+        serializer(records);
     }
 
 private:

opm/input/eclipse/Schedule/UDQ/UDQConfig.hpp

@@ -95,12 +95,12 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            udq_params.serializeOp(serializer);
-            serializer.map(m_definitions);
-            serializer.map(m_assignments);
+            serializer(udq_params);
+            serializer(m_definitions);
+            serializer(m_assignments);
             serializer(units);
-            input_index.serializeOp(serializer);
-            serializer.map(type_count);
+            serializer(input_index);
+            serializer(type_count);
             // The UDQFunction table is constant up to udq_params.
             // So we can just construct a new instance here.
             if (!serializer.isSerializing())

opm/input/eclipse/Schedule/UDQ/UDQDefine.hpp

@@ -88,7 +88,7 @@ public:
         serializer(m_keyword);
         serializer(ast);
         serializer(m_var_type);
-        m_location.serializeOp(serializer);
+        serializer(m_location);
         serializer(string_data);
         serializer(m_update_status);
         serializer(m_report_step);

opm/input/eclipse/Schedule/UDQ/UDQState.hpp

@@ -78,14 +78,14 @@ public:
         if (serializer.isSerializing()) {
             for (auto& [udq_key, values] : wgmap) {
                 serializer(udq_key);
-                serializer.map(values);
+                serializer(values);
             }
         } else {
             for (std::size_t index=0; index < map_size; index++) {
                 std::string udq_key;
                 std::unordered_map<std::string, double> inner_map;
                 serializer(udq_key);
-                serializer.map(inner_map);
+                serializer(inner_map);
 
                 wgmap.emplace(udq_key, inner_map);
             }
@@ -96,9 +96,9 @@ public:
     void serializeOp(Serializer& serializer)
     {
         serializer(this->undef_value);
-        serializer.map(this->scalar_values);
-        serializer.map(this->assignments);
-        serializer.map(this->defines);
+        serializer(this->scalar_values);
+        serializer(this->assignments);
+        serializer(this->defines);
 
         pack_unpack_wgmap(serializer, this->well_values);
         pack_unpack_wgmap(serializer, this->group_values);

opm/input/eclipse/Schedule/VFPInjTable.hpp

@@ -108,7 +108,7 @@ public:
         serializer(m_flo_data);
         serializer(m_thp_data);
         serializer(m_data);
-        m_location.serializeOp(serializer);
+        serializer(m_location);
     }
 
 private:

opm/input/eclipse/Schedule/VFPProdTable.hpp

@@ -176,7 +176,7 @@ public:
         serializer(m_gfr_data);
         serializer(m_alq_data);
         serializer(m_data);
-        m_location.serializeOp(serializer);
+        serializer(m_location);
     }
 
 private:

opm/input/eclipse/Schedule/Well/NameOrder.hpp

@@ -48,7 +48,7 @@ public:
 
     template<class Serializer>
     void serializeOp(Serializer& serializer) {
-        serializer.map(m_index_map);
+        serializer(m_index_map);
         serializer(m_name_list);
     }
 

opm/input/eclipse/Schedule/Well/WListManager.hpp

@@ -55,9 +55,9 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.map(wlists);
-        serializer.map(well_wlist_names);
-        serializer.map(no_wlists_well);
+        serializer(wlists);
+        serializer(well_wlist_names);
+        serializer(no_wlists_well);
     }
 
 private:

opm/input/eclipse/Schedule/Well/Well.hpp

@@ -309,10 +309,10 @@ public:
         void serializeOp(Serializer& serializer)
         {
             serializer(name);
-            surfaceInjectionRate.serializeOp(serializer);
-            reservoirInjectionRate.serializeOp(serializer);
-            BHPTarget.serializeOp(serializer);
-            THPTarget.serializeOp(serializer);
+            serializer(surfaceInjectionRate);
+            serializer(reservoirInjectionRate);
+            serializer(BHPTarget);
+            serializer(THPTarget);
             serializer(bhp_hist_limit);
             serializer(thp_hist_limit);
             serializer(temperature);
@@ -442,14 +442,14 @@ public:
         void serializeOp(Serializer& serializer)
         {
             serializer(name);
-            OilRate.serializeOp(serializer);
-            WaterRate.serializeOp(serializer);
-            GasRate.serializeOp(serializer);
-            LiquidRate.serializeOp(serializer);
-            ResVRate.serializeOp(serializer);
-            BHPTarget.serializeOp(serializer);
-            THPTarget.serializeOp(serializer);
-            ALQValue.serializeOp(serializer);
+            serializer(OilRate);
+            serializer(WaterRate);
+            serializer(GasRate);
+            serializer(LiquidRate);
+            serializer(ResVRate);
+            serializer(BHPTarget);
+            serializer(THPTarget);
+            serializer(ALQValue);
             serializer(bhp_hist_limit);
             serializer(thp_hist_limit);
             serializer(BHPH);
@@ -663,7 +663,7 @@ public:
         serializer(headJ);
         serializer(ref_depth);
         serializer(wpave_ref_depth);
-        unit_system.serializeOp(serializer);
+        serializer(unit_system);
         serializer(udq_undefined);
         serializer(status);
         serializer(drainage_radius);
@@ -671,8 +671,8 @@ public:
         serializer(automatic_shutin);
         serializer(pvt_table);
         serializer(gas_inflow);
-        wtype.serializeOp(serializer);
-        guide_rate.serializeOp(serializer);
+        serializer(wtype);
+        serializer(guide_rate);
         serializer(efficiency_factor);
         serializer(solvent_fraction);
         serializer(has_produced);
@@ -689,7 +689,7 @@ public:
         serializer(injection);
         serializer(segments);
         serializer(wvfpexp);
-        m_pavg.serializeOp(serializer);
+        serializer(m_pavg);
     }
 
 private:

opm/input/eclipse/Schedule/Well/WellConnections.hpp

@@ -151,7 +151,7 @@ namespace Opm {
             serializer(this->m_ordering);
             serializer(this->headI);
             serializer(this->headJ);
-            serializer.vector(this->m_connections);
+            serializer(this->m_connections);
         }
 
     private:

opm/input/eclipse/Schedule/Well/WellTestConfig.hpp

@@ -124,7 +124,7 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.map(wells);
+        serializer(wells);
     }
 
 private:

opm/input/eclipse/Schedule/Well/WellTestState.hpp

@@ -256,13 +256,13 @@ public:
     template<class Serializer>
     void serializeOp(Serializer& serializer)
     {
-        serializer.map(this->wells);
+        serializer(this->wells);
         if (serializer.isSerializing()) {
             std::size_t size = this->completions.size();
             serializer(size);
             for (auto& [well, comp_map] : this->completions) {
                 serializer(well);
-                serializer.map(comp_map);
+                serializer(comp_map);
             }
         } else {
             std::size_t size = 0;
@@ -272,7 +272,7 @@ public:
                 std::unordered_map<int, ClosedCompletion> comp_map;
 
                 serializer(well);
-                serializer.map(comp_map);
+                serializer(comp_map);
                 this->completions.emplace(well, std::move(comp_map));
             }
         }

opm/input/eclipse/Units/UnitSystem.hpp

@@ -133,7 +133,7 @@ namespace Opm {
         {
             serializer(m_name);
             serializer(m_unittype);
-            serializer.map(m_dimensions);
+            serializer(m_dimensions);
             serializer(m_use_count);
             if (!serializer.isSerializing())
                 init();

opm/output/data/Aquifer.hpp

@@ -238,7 +238,7 @@ namespace Opm { namespace data {
        template<class Serializer>
        void serializeOp(Serializer& serializer)
        {
-           serializer.variant(options_);
+           serializer(options_);
        }
 
     private:
@@ -347,7 +347,7 @@ namespace Opm { namespace data {
             serializer(volume);
             serializer(initPressure);
             serializer(datumDepth);
-            typeData.serializeOp(serializer);
+            serializer(typeData);
         }
 
         static AquiferData serializeObjectF()

opm/output/data/Groups.hpp

@@ -112,8 +112,8 @@ namespace Opm { namespace data {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            production.serializeOp(serializer);
-            injection.serializeOp(serializer);
+            serializer(production);
+            serializer(injection);
         }
 
         static GroupGuideRates serializeObject()
@@ -159,8 +159,8 @@ namespace Opm { namespace data {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            currentControl.serializeOp(serializer);
-            guideRates.serializeOp(serializer);
+            serializer(currentControl);
+            serializer(guideRates);
         }
 
         static GroupData serializeObject()
@@ -260,16 +260,16 @@ namespace Opm { namespace data {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            serializer.map(groupData);
-            serializer.map(nodeData);
+            serializer(groupData);
+            serializer(nodeData);
         }
 
         static GroupAndNetworkValues serializeObject()
         {
-          return GroupAndNetworkValues{
-                      {{"test_data", GroupData::serializeObject()}},
-                      {{"test_node", NodeData::serializeObject()}}
-                 };
+            return GroupAndNetworkValues{
+                        {{"test_data", GroupData::serializeObject()}},
+                        {{"test_node", NodeData::serializeObject()}}
+                   };
         }
 
     private:

opm/output/data/Solution.hpp

@@ -58,7 +58,7 @@ class Solution : public std::map< std::string, data::CellData > {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-          serializer.map(*this);
+          serializer(static_cast<Base&>(*this));
           serializer(si);
         }
 

opm/output/data/Wells.hpp

@@ -231,15 +231,15 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-          serializer(index);
-          rates.serializeOp(serializer);
-          serializer(pressure);
-          serializer(reservoir_rate);
-          serializer(cell_pressure);
-          serializer(cell_saturation_water);
-          serializer(cell_saturation_gas);
-          serializer(effective_Kh);
-          serializer(trans_factor);
+            serializer(index);
+            serializer(rates);
+            serializer(pressure);
+            serializer(reservoir_rate);
+            serializer(cell_pressure);
+            serializer(cell_saturation_water);
+            serializer(cell_saturation_gas);
+            serializer(effective_Kh);
+            serializer(trans_factor);
         }
 
         static Connection serializeObject()
@@ -290,7 +290,7 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-          serializer(values_);
+            serializer(values_);
         }
 
         static SegmentPressures serializeObject()
@@ -337,8 +337,8 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-            rates.serializeOp(serializer);
-            pressures.serializeOp(serializer);
+            serializer(rates);
+            serializer(pressures);
             serializer(segNumber);
         }
 
@@ -453,46 +453,46 @@ namespace Opm {
 
         bool operator==(const Well& well2) const
         {
-          return rates == well2.rates &&
-                 bhp == well2.bhp &&
-                 thp == well2.thp &&
-                 temperature == well2.temperature &&
-                 control == well2.control &&
-                 dynamicStatus == well2.dynamicStatus &&
-                 connections == well2.connections &&
-                 segments == well2.segments &&
-                 current_control == well2.current_control &&
-                 guide_rates == well2.guide_rates;
+            return rates == well2.rates &&
+                   bhp == well2.bhp &&
+                   thp == well2.thp &&
+                   temperature == well2.temperature &&
+                   control == well2.control &&
+                   dynamicStatus == well2.dynamicStatus &&
+                   connections == well2.connections &&
+                   segments == well2.segments &&
+                   current_control == well2.current_control &&
+                   guide_rates == well2.guide_rates;
         }
 
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-          rates.serializeOp(serializer);
-          serializer(bhp);
-          serializer(thp);
-          serializer(temperature);
-          serializer(control);
-          serializer(dynamicStatus);
-          serializer.vector(connections);
-          serializer.map(segments);
-          current_control.serializeOp(serializer);
-          guide_rates.serializeOp(serializer);
+            serializer(rates);
+            serializer(bhp);
+            serializer(thp);
+            serializer(temperature);
+            serializer(control);
+            serializer(dynamicStatus);
+            serializer(connections);
+            serializer(segments);
+            serializer(current_control);
+            serializer(guide_rates);
         }
 
         static Well serializeObject()
         {
-          return Well{Rates::serializeObject(),
-                      1.0,
-                      2.0,
-                      3.0,
-                      4,
-                      ::Opm::Well::Status::SHUT,
-                      {Connection::serializeObject()},
-                      {{0, Segment::serializeObject()}},
-                      CurrentControl::serializeObject(),
-                      GuideRateValue::serializeObject()
-                 };
+            return Well{Rates::serializeObject(),
+                        1.0,
+                        2.0,
+                        3.0,
+                        4,
+                        ::Opm::Well::Status::SHUT,
+                        {Connection::serializeObject()},
+                        {{0, Segment::serializeObject()}},
+                        CurrentControl::serializeObject(),
+                        GuideRateValue::serializeObject()
+                   };
         }
     };
 
@@ -572,7 +572,7 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-          serializer.map(*this);
+            serializer(static_cast<std::map<std::string,Well>&>(*this));
         }
 
         static Wells serializeObject()

opm/output/eclipse/RestartValue.hpp

@@ -116,11 +116,11 @@ namespace Opm {
         template<class Serializer>
         void serializeOp(Serializer& serializer)
         {
-          solution.serializeOp(serializer);
-          wells.serializeOp(serializer);
-          grp_nwrk.serializeOp(serializer);
-          serializer.map(aquifer);
-          serializer.vector(extra);
+          serializer(solution);
+          serializer(wells);
+          serializer(grp_nwrk);
+          serializer(aquifer);
+          serializer(extra);
         }
 
         static RestartValue serializeObject()