#10648 Refactor summary reader: return std::vector<double> instead of taking ptr.

ApplicationLibCode/Application/RiaSummaryCurveDefinition.cpp

@@ -204,15 +204,16 @@ void RiaSummaryCurveDefinition::setIdentifierText( SummaryCategory category, con
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RiaSummaryCurveDefinition::resultValues( const RiaSummaryCurveDefinition& curveDefinition, gsl::not_null<std::vector<double>*> values )
+std::vector<double> RiaSummaryCurveDefinition::resultValues( const RiaSummaryCurveDefinition& curveDefinition )
 {
-    if ( !curveDefinition.summaryAddressY().isValid() ) return;
+    if ( !curveDefinition.summaryAddressY().isValid() ) return {};
-    if ( !curveDefinition.summaryCaseY() ) return;
+    if ( !curveDefinition.summaryCaseY() ) return {};
 
     RifSummaryReaderInterface* reader = curveDefinition.summaryCaseY()->summaryReader();
-    if ( !reader ) return;
+    if ( !reader ) return {};
 
-    reader->values( curveDefinition.summaryAddressY(), values );
+    auto [isOk, values] = reader->values( curveDefinition.summaryAddressY() );
+    return values;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/Application/RiaSummaryCurveDefinition.h

@@ -66,7 +66,7 @@ public:
     bool operator<( const RiaSummaryCurveDefinition& other ) const;
 
     // TODO: Consider moving to a separate tools class
-    static void                resultValues( const RiaSummaryCurveDefinition& curveDefinition, gsl::not_null<std::vector<double>*> values );
+    static std::vector<double> resultValues( const RiaSummaryCurveDefinition& curveDefinition );
     static std::vector<time_t> timeSteps( const RiaSummaryCurveDefinition& curveDefinition );
 
     QString curveDefinitionText() const;

ApplicationLibCode/Commands/CompletionExportCommands/RicExportFractureCompletionsImpl.cpp

@@ -454,8 +454,8 @@ void RicExportFractureCompletionsImpl::getWellPressuresAndInitialProductionTimeS
 
             if ( summaryCase && summaryCase->summaryReader() )
             {
-                std::vector<double> values;
+                auto [isOk, values] = summaryCase->summaryReader()->values( wbhpPressureAddress );
-                if ( summaryCase->summaryReader()->values( wbhpPressureAddress, &values ) )
+                if ( isOk )
                 {
                     std::vector<time_t> summaryTimeSteps = summaryCase->summaryReader()->timeSteps( wbhpPressureAddress );
                     CVF_ASSERT( values.size() == summaryTimeSteps.size() );

ApplicationLibCode/FileInterface/RifColumnBasedUserData.cpp

@@ -72,28 +72,31 @@ bool RifColumnBasedUserData::parse( const QString& data, QString* errorText )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifColumnBasedUserData::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RifColumnBasedUserData::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
+    std::vector<double> values;
+
     auto search = m_mapFromAddressToResultIndex.find( resultAddress );
+
     if ( search != m_mapFromAddressToResultIndex.end() )
     {
         std::pair<size_t, size_t> tableColIndices = search->second;
 
         const Column* ci = m_parser->columnInfo( tableColIndices.first, tableColIndices.second );
-        if ( !ci ) return false;
+        if ( !ci ) return { false, {} };
 
         if ( !ci->values.empty() )
         {
-            values->reserve( ci->values.size() );
+            values.reserve( ci->values.size() );
 
             for ( const auto& v : ci->values )
             {
-                values->push_back( v );
+                values.push_back( v );
             }
         }
     }
 
-    return true;
+    return { true, values };
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/FileInterface/RifColumnBasedUserData.h

@@ -44,7 +44,7 @@ public:
 
     std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
 
-    bool values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
 
     std::string                   unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem unitSystem() const override;

ApplicationLibCode/FileInterface/RifCsvSummaryReader.cpp

@@ -49,25 +49,26 @@ RifCsvSummaryReader::~RifCsvSummaryReader()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifCsvSummaryReader::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RifCsvSummaryReader::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
+    std::vector<double> values;
+
     auto search = m_mapFromAddressToResultIndex.find( resultAddress );
     if ( search != m_mapFromAddressToResultIndex.end() )
     {
         size_t columnIndex = search->second;
 
         const Column* ci = m_parser->columnInfo( columnIndex );
-        if ( !ci ) return false;
+        if ( !ci ) return { false, {} };
 
-        values->clear();
+        values.reserve( ci->values.size() );
-        values->reserve( ci->values.size() );
         for ( double val : ci->values )
         {
-            values->push_back( val );
+            values.push_back( val );
         }
     }
 
-    return true;
+    return { true, values };
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/FileInterface/RifCsvSummaryReader.h

@@ -41,7 +41,7 @@ public:
 
     std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
 
-    bool values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
 
     std::string unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
 

ApplicationLibCode/FileInterface/RifCsvUserData.cpp

@@ -69,25 +69,25 @@ bool RifCsvUserData::parse( const QString& fileName, const AsciiDataParseOptions
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifCsvUserData::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RifCsvUserData::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
+    std::vector<double> values;
     auto                search = m_mapFromAddressToResultIndex.find( resultAddress );
     if ( search != m_mapFromAddressToResultIndex.end() )
     {
         size_t columnIndex = search->second;
 
         const Column* ci = m_parser->columnInfo( columnIndex );
-        if ( !ci ) return false;
+        if ( !ci ) return { false, {} };
 
-        values->clear();
+        values.reserve( ci->values.size() );
-        values->reserve( ci->values.size() );
         for ( double val : ci->values )
         {
-            values->push_back( val );
+            values.push_back( val );
         }
     }
 
-    return true;
+    return { true, values };
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/FileInterface/RifCsvUserData.h

@@ -46,7 +46,7 @@ public:
 
     std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
 
-    bool values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
 
     std::string unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
 

ApplicationLibCode/FileInterface/RifDerivedEnsembleReader.cpp

@@ -70,20 +70,22 @@ std::vector<time_t> RifDerivedEnsembleReader::timeSteps( const RifEclipseSummary
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifDerivedEnsembleReader::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RifDerivedEnsembleReader::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
-    if ( !resultAddress.isValid() ) return false;
+    if ( !resultAddress.isValid() ) return { false, {} };
 
     if ( m_derivedCase->needsCalculation( resultAddress ) )
     {
         m_derivedCase->calculate( resultAddress );
     }
+
     auto dataValues = m_derivedCase->values( resultAddress );
-    values->clear();
+
-    values->reserve( dataValues.size() );
+    std::vector<double> values;
+    values.reserve( dataValues.size() );
     for ( auto val : dataValues )
-        values->push_back( val );
+        values.push_back( val );
-    return true;
+    return { true, values };
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/FileInterface/RifDerivedEnsembleReader.h

@@ -35,7 +35,7 @@ public:
                               RifSummaryReaderInterface* sourceSummaryReader2 );
 
     std::vector<time_t>                  timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
-    bool                          values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
     std::string                          unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem        unitSystem() const override;
 

ApplicationLibCode/FileInterface/RifEclEclipseSummary.cpp

@@ -256,19 +256,17 @@ RifEclipseSummaryAddress addressFromErtSmSpecNode( const ecl::smspec_node& ertSu
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifEclEclipseSummary::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RifEclEclipseSummary::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
-    CVF_ASSERT( values );
+    if ( m_timeSteps.empty() ) return { true, {} };
 
-    if ( m_timeSteps.empty() ) return true;
+    std::vector<double> values;
-
+    values.reserve( m_timeSteps.size() );
-    values->clear();
-    values->reserve( m_timeSteps.size() );
 
     if ( m_ecl_SmSpec )
     {
         int variableIndex = indexFromAddress( resultAddress );
-        if ( variableIndex < 0 ) return false;
+        if ( variableIndex < 0 ) return { false, {} };
 
         const ecl::smspec_node& ertSumVarNode = ecl_smspec_iget_node_w_node_index( m_ecl_SmSpec, variableIndex );
         int                     paramsIndex   = ertSumVarNode.get_params_index();
@@ -279,12 +277,12 @@ bool RifEclEclipseSummary::values( const RifEclipseSummaryAddress& resultAddress
         {
             int           dataSize = double_vector_size( dataValues );
             const double* dataPtr  = double_vector_get_const_ptr( dataValues );
-            values->insert( values->end(), dataPtr, dataPtr + dataSize );
+            values.insert( values.end(), dataPtr, dataPtr + dataSize );
             double_vector_free( dataValues );
         }
     }
 
-    return true;
+    return { true, values };
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/FileInterface/RifEclEclipseSummary.h

@@ -50,7 +50,7 @@ public:
 
     std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
 
-    bool                          values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
     std::string                          unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem        unitSystem() const override;
 

ApplicationLibCode/FileInterface/RifKeywordVectorUserData.cpp

@@ -176,17 +176,18 @@ bool RifKeywordVectorUserData::parse( const QString& data, const QString& custom
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifKeywordVectorUserData::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RifKeywordVectorUserData::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
     auto search = m_mapFromAddressToVectorIndex.find( resultAddress );
-    if ( search == m_mapFromAddressToVectorIndex.end() ) return false;
+    if ( search == m_mapFromAddressToVectorIndex.end() ) return { false, {} };
 
+    std::vector<double> values;
     for ( const auto& v : m_parser->keywordBasedVectors()[search->second].values )
     {
-        values->push_back( v );
+        values.push_back( v );
     }
 
-    return true;
+    return { true, values };
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/FileInterface/RifKeywordVectorUserData.h

@@ -45,7 +45,7 @@ public:
 
     std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
 
-    bool values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
 
     std::string                   unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem unitSystem() const override;

ApplicationLibCode/FileInterface/RifMultipleSummaryReaders.cpp

@@ -64,14 +64,14 @@ std::vector<time_t> RifMultipleSummaryReaders::timeSteps( const RifEclipseSummar
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifMultipleSummaryReaders::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RifMultipleSummaryReaders::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
     for ( const auto& r : m_readers )
     {
-        if ( r->hasAddress( resultAddress ) ) return r->values( resultAddress, values );
+        if ( r->hasAddress( resultAddress ) ) return r->values( resultAddress );
     }
 
-    return false;
+    return { false, {} };
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/FileInterface/RifMultipleSummaryReaders.h

@@ -36,7 +36,7 @@ public:
     void removeReader( RifSummaryReaderInterface* reader );
 
     std::vector<time_t>                  timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
-    bool                          values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
     std::string                          unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem        unitSystem() const override;
 

ApplicationLibCode/FileInterface/RifOpmCommonSummary.cpp

@@ -148,26 +148,27 @@ std::vector<time_t> RifOpmCommonEclipseSummary::timeSteps( const RifEclipseSumma
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifOpmCommonEclipseSummary::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RifOpmCommonEclipseSummary::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
     auto it = m_summaryAddressToKeywordMap.find( resultAddress );
     if ( it != m_summaryAddressToKeywordMap.end() )
     {
+        std::vector<double> values;
         auto                keyword = it->second;
         if ( m_enhancedReader )
         {
             auto fileValues = m_enhancedReader->get( keyword );
-            values->insert( values->begin(), fileValues.begin(), fileValues.end() );
+            values.insert( values.begin(), fileValues.begin(), fileValues.end() );
         }
         else if ( m_standardReader )
         {
             auto fileValues = m_standardReader->get( keyword );
-            values->insert( values->begin(), fileValues.begin(), fileValues.end() );
+            values.insert( values.begin(), fileValues.begin(), fileValues.end() );
         }
-        return true;
+        return { true, values };
     }
 
-    return false;
+    return { false, {} };
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/FileInterface/RifOpmCommonSummary.h

@@ -73,7 +73,7 @@ public:
     bool open( const QString& fileName, bool includeRestartFiles, RiaThreadSafeLogger* threadSafeLogger );
 
     std::vector<time_t>                  timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
-    bool                          values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
     std::string                          unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem        unitSystem() const override;
 

ApplicationLibCode/FileInterface/RifOpmHdf5Summary.cpp

@@ -91,7 +91,7 @@ std::vector<time_t> RifOpmHdf5Summary::timeSteps( const RifEclipseSummaryAddress
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifOpmHdf5Summary::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RifOpmHdf5Summary::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
     if ( m_eSmry && m_hdf5Reader )
     {
@@ -103,14 +103,13 @@ bool RifOpmHdf5Summary::values( const RifEclipseSummaryAddress& resultAddress, s
 
             if ( smspecIndex != std::numeric_limits<size_t>::max() )
             {
-                *values = m_hdf5Reader->values( vectorName, static_cast<int>( smspecIndex ) );
+                std::vector<double> values = m_hdf5Reader->values( vectorName, static_cast<int>( smspecIndex ) );
-
+                return { true, values };
-                return true;
             }
         }
     }
 
-    return false;
+    return { false, {} };
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/FileInterface/RifOpmHdf5Summary.h

@@ -57,7 +57,7 @@ public:
     bool open( const QString& headerFileName, bool includeRestartFiles, RiaThreadSafeLogger* threadSafeLogger );
 
     std::vector<time_t>                  timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
-    bool                          values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
     std::string                          unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem        unitSystem() const override;
 

ApplicationLibCode/FileInterface/RifProjectSummaryDataWriter.cpp

@@ -59,8 +59,7 @@ void RifProjectSummaryDataWriter::importFromSourceSummaryReader( const RifSummar
             m_startTime = { ts.day(), ts.month(), ts.year(), ts.hour(), ts.minutes(), ts.seconds(), 0 };
         }
 
-        std::vector<double> values;
+        auto [isOk, values] = reader->values( summaryAddress );
-        reader->values( summaryAddress, &values );
 
         const auto& unitString = reader->unitName( summaryAddress );
 

ApplicationLibCode/FileInterface/RifReaderEclipseSummary.cpp

@@ -159,21 +159,18 @@ bool RifReaderEclipseSummary::open( const QString& headerFileName, RiaThreadSafe
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifReaderEclipseSummary::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RifReaderEclipseSummary::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
-    CVF_ASSERT( values );
+    if ( timeSteps( resultAddress ).empty() ) return { false, {} };
 
-    if ( timeSteps( resultAddress ).empty() ) return false;
+    std::vector<double> values;
-
+    values.reserve( timeSteps( resultAddress ).size() );
-    values->clear();
-    values->reserve( timeSteps( resultAddress ).size() );
 
     const std::vector<double>& cachedValues = m_valuesCache->getValues( resultAddress );
     if ( !cachedValues.empty() )
     {
-        values->insert( values->begin(), cachedValues.begin(), cachedValues.end() );
+        values.insert( values.begin(), cachedValues.begin(), cachedValues.end() );
-
+        return { true, values };
-        return true;
     }
 
     if ( m_differenceAddresses.count( resultAddress ) )
@@ -188,35 +185,33 @@ bool RifReaderEclipseSummary::values( const RifEclipseSummaryAddress& resultAddr
         RifEclipseSummaryAddress nativeAdrHistory = resultAddress;
         nativeAdrHistory.setVectorName( quantityNoHistory );
 
-        std::vector<double> nativeValues;
+        auto [nativeValuesOk, nativeValues] = this->values( nativeAdrHistory );
-        std::vector<double> historyValues;
+        if ( !nativeValuesOk ) return { false, {} };
 
-        if ( !this->values( nativeAdrHistory, &nativeValues ) ) return false;
+        auto [nativeAdrNoHistoryOk, historyValues] = this->values( nativeAdrNoHistory );
-        if ( !this->values( nativeAdrNoHistory, &historyValues ) ) return false;
+        if ( !nativeAdrNoHistoryOk ) return { false, {} };
 
-        if ( nativeValues.size() != historyValues.size() ) return false;
+        if ( nativeValues.size() != historyValues.size() ) return { false, {} };
 
         for ( size_t i = 0; i < nativeValues.size(); i++ )
         {
             double diff = nativeValues[i] - historyValues[i];
-            values->push_back( diff );
+            values.push_back( diff );
-            m_valuesCache->insertValues( resultAddress, *values );
+            m_valuesCache->insertValues( resultAddress, values );
         }
 
-        return true;
+        return { true, values };
     }
 
     auto reader = currentSummaryReader();
     if ( reader )
     {
-        auto status = reader->values( resultAddress, values );
+        auto [status, values] = reader->values( resultAddress );
-
+        if ( status ) m_valuesCache->insertValues( resultAddress, values );
-        if ( status ) m_valuesCache->insertValues( resultAddress, *values );
+        return { status, values };
-
-        return status;
     }
 
-    return true;
+    return { true, values };
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/FileInterface/RifReaderEclipseSummary.h

@@ -51,7 +51,7 @@ public:
 
     std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
 
-    bool                          values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
     std::string                          unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem        unitSystem() const override;
 

ApplicationLibCode/FileInterface/RifReaderObservedData.cpp

@@ -114,7 +114,7 @@ bool RifReaderObservedData::open( const QString&
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifReaderObservedData::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RifReaderObservedData::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
     size_t columnIndex = m_allResultAddresses.size();
 
@@ -128,6 +128,7 @@ bool RifReaderObservedData::values( const RifEclipseSummaryAddress& resultAddres
         i++;
     }
 
+    std::vector<double> values;
     if ( columnIndex != m_allResultAddresses.size() )
     {
         const Column* col = m_asciiParser->columnInfo( columnIndex );
@@ -135,12 +136,12 @@ bool RifReaderObservedData::values( const RifEclipseSummaryAddress& resultAddres
         {
             for ( auto& v : col->values )
             {
-                values->push_back( v );
+                values.push_back( v );
             }
         }
     }
 
-    return true;
+    return { true, values };
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/FileInterface/RifReaderObservedData.h

@@ -45,7 +45,7 @@ public:
 
     std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
 
-    bool values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
 
     std::string unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
 

ApplicationLibCode/FileInterface/RifSummaryReaderInterface.h

@@ -46,7 +46,7 @@ public:
 
     virtual std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const = 0;
 
-    virtual bool values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const = 0;
+    virtual std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const = 0;
 
     virtual std::string                   unitName( const RifEclipseSummaryAddress& resultAddress ) const = 0;
     virtual RiaDefines::EclipseUnitSystem unitSystem() const                                              = 0;

ApplicationLibCode/FileInterface/RifSummaryReaderMultipleFiles.cpp

@@ -43,12 +43,12 @@ std::vector<time_t> RifSummaryReaderMultipleFiles::timeSteps( const RifEclipseSu
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifSummaryReaderMultipleFiles::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RifSummaryReaderMultipleFiles::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
+    std::vector<double> values;
     for ( const auto& reader : m_summaryReaders )
     {
-        std::vector<double> readerValues;
+        auto [isOk, readerValues] = reader->values( resultAddress );
-        reader->values( resultAddress, &readerValues );
 
         if ( readerValues.empty() )
         {
@@ -60,19 +60,18 @@ bool RifSummaryReaderMultipleFiles::values( const RifEclipseSummaryAddress& resu
             // https://github.com/OPM/ResInsight/issues/7065
 
             std::vector<double> zeros( reader->timeSteps( {} ).size(), 0.0 );
-
             readerValues = zeros;
         }
 
         auto valueCount = timeStepCount( reader.get() );
         readerValues.resize( valueCount );
 
-        values->insert( values->end(), readerValues.begin(), readerValues.end() );
+        values.insert( values.end(), readerValues.begin(), readerValues.end() );
     }
 
-    CAF_ASSERT( m_aggregatedTimeSteps.size() == values->size() );
+    CAF_ASSERT( m_aggregatedTimeSteps.size() == values.size() );
 
-    return true;
+    return { true, values };
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/FileInterface/RifSummaryReaderMultipleFiles.h

@@ -40,7 +40,7 @@ public:
     bool createReadersAndImportMetaData( RiaThreadSafeLogger* threadSafeLogger );
 
     std::vector<time_t>                  timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
-    bool                          values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
     std::string                          unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem        unitSystem() const override;
 

ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlot.cpp

@@ -341,9 +341,7 @@ void RimAnalysisPlot::maxMinValueFromAddress( const RifEclipseSummaryAddress&
 
         if ( reader->hasAddress( address ) )
         {
-            std::vector<double> values;
+            auto [isOk, values]                  = reader->values( address );
-            reader->values( address, &values );
-
             const std::vector<time_t>& timesteps = reader->timeSteps( address );
 
             if ( !timesteps.empty() && !values.empty() )
@@ -1174,8 +1172,7 @@ void RimAnalysisPlot::applyFilter( const RimPlotDataFilterItem*        filter,
 
                 if ( reader->hasAddress( addrToFilterValue ) )
                 {
-                    std::vector<double> values;
+                    auto [isOk, values]                  = reader->values( addrToFilterValue );
-                    reader->values( addrToFilterValue, &values );
                     const std::vector<time_t>& timesteps = reader->timeSteps( addrToFilterValue );
 
                     if ( filter->consideredTimeStepsType() == RimPlotDataFilterItem::ALL_TIMESTEPS )
@@ -1445,7 +1442,8 @@ void RimAnalysisPlot::addDataToChartBuilder( RiuGroupedBarChartBuilder& chartBui
         {
             timeSteps = reader->timeSteps( curveDef.summaryAddressY() );
 
-            reader->values( curveDef.summaryAddressY(), &values );
+            auto [isOk, readValues] = reader->values( curveDef.summaryAddressY() );
+            values.swap( readValues );
         }
 
         if ( timeSteps.empty() || values.empty() ) continue;

ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimCorrelationMatrixPlot.cpp

@@ -534,10 +534,10 @@ void RimCorrelationMatrixPlot::createMatrix()
                         RifSummaryReaderInterface* reader = summaryCase->summaryReader();
                         if ( reader )
                         {
-                            std::vector<double> values;
                             double closestValue    = std::numeric_limits<double>::infinity();
                             time_t closestTimeStep = 0;
-                            if ( reader->values( address, &values ) )
+                            auto [isOk, values]    = reader->values( address );
+                            if ( isOk )
                             {
                                 const std::vector<time_t>& timeSteps = reader->timeSteps( address );
                                 for ( size_t i = 0; i < timeSteps.size(); ++i )

ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimParameterResultCrossPlot.cpp

@@ -261,11 +261,10 @@ void RimParameterResultCrossPlot::createPoints()
 
                 if ( !summaryCase->caseRealizationParameters() ) continue;
 
-                std::vector<double> values;
-
                 double closestValue    = std::numeric_limits<double>::infinity();
                 time_t closestTimeStep = 0;
-                if ( reader->values( address, &values ) )
+                auto [isOk, values]    = reader->values( address );
+                if ( isOk )
                 {
                     const std::vector<time_t>& timeSteps = reader->timeSteps( address );
                     for ( size_t i = 0; i < timeSteps.size(); ++i )

ApplicationLibCode/ProjectDataModel/RimSimWellInViewTools.cpp

@@ -159,8 +159,7 @@ double RimSimWellInViewTools::extractValueForTimeStep( RifSummaryReaderInterface
         return 0.0;
     }
 
-    std::vector<double> values;
+    auto [isOkReader, values]     = summaryReader->values( addr );
-    summaryReader->values( addr, &values );
     std::vector<time_t> timeSteps = summaryReader->timeSteps( addr );
     if ( values.empty() || timeSteps.empty() )
     {

ApplicationLibCode/ProjectDataModel/RimSummaryCalculation.cpp

@@ -332,8 +332,7 @@ std::optional<std::pair<std::vector<double>, std::vector<time_t>>>
 
         RiaSummaryCurveDefinition curveDef( summaryCase, v.summaryAddress, false );
 
-        std::vector<double> curveValues;
+        std::vector<double> curveValues = RiaSummaryCurveDefinition::resultValues( curveDef );
-        RiaSummaryCurveDefinition::resultValues( curveDef, &curveValues );
 
         std::vector<time_t> curveTimeSteps = RiaSummaryCurveDefinition::timeSteps( curveDef );
 

ApplicationLibCode/ProjectDataModel/Summary/RimCalculatedSummaryCurveReader.cpp

@@ -52,18 +52,16 @@ std::vector<time_t> RifCalculatedSummaryCurveReader::timeSteps( const RifEclipse
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifCalculatedSummaryCurveReader::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RifCalculatedSummaryCurveReader::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
     RimSummaryCalculation* calc = findCalculationByName( resultAddress );
     if ( calc && m_summaryCase )
     {
         RimSummaryCalculationAddress address( resultAddress );
-        *values = calc->values( m_summaryCase, address );
+        return { true, calc->values( m_summaryCase, address ) };
-
-        return true;
     }
 
-    return false;
+    return { false, {} };
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Summary/RimCalculatedSummaryCurveReader.h

@@ -36,7 +36,7 @@ public:
     explicit RifCalculatedSummaryCurveReader( RimSummaryCalculationCollection* calculationCollection, RimSummaryCase* summaryCase );
 
     std::vector<time_t>                  timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
-    bool                values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
     std::string                          unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
 
     void buildMetaData();

ApplicationLibCode/ProjectDataModel/Summary/RimDerivedSummaryCase.cpp

@@ -205,16 +205,12 @@ std::pair<std::vector<time_t>, std::vector<double>> RimDerivedSummaryCase::calcu
 
     if ( reader1->hasAddress( address ) && !reader2->hasAddress( address ) )
     {
-        std::vector<double> summaryValues;
+        auto [isOk, summaryValues] = reader1->values( address );
-        reader1->values( address, &summaryValues );
-
         return ResultPair( reader1->timeSteps( address ), summaryValues );
     }
     else if ( !reader1->hasAddress( address ) && reader2->hasAddress( address ) )
     {
-        std::vector<double> summaryValues;
+        auto [isOk, summaryValues] = reader2->values( address );
-        reader2->values( address, &summaryValues );
-
         if ( m_operator == DerivedSummaryOperator::DERIVED_OPERATOR_SUB )
         {
             for ( auto& v : summaryValues )
@@ -226,18 +222,15 @@ std::pair<std::vector<time_t>, std::vector<double>> RimDerivedSummaryCase::calcu
         return ResultPair( reader2->timeSteps( address ), summaryValues );
     }
 
-    RiaTimeHistoryCurveMerger merger;
+    auto [isOk1, values1] = reader1->values( address );
-    std::vector<double>       values1;
+    auto [isOk2, values2] = reader2->values( address );
-    std::vector<double>       values2;
-
-    reader1->values( address, &values1 );
-    reader2->values( address, &values2 );
 
     if ( values1.empty() && values2.empty() )
     {
         return ResultPair();
     }
 
+    RiaTimeHistoryCurveMerger merger;
     merger.addCurveData( reader1->timeSteps( address ), values1 );
     merger.addCurveData( reader2->timeSteps( address ), values2 );
     merger.computeInterpolatedValues();

ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleCrossPlotStatisticsCase.cpp

@@ -36,7 +36,7 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimEnsembleCrossPlotStatisticsCase::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RimEnsembleCrossPlotStatisticsCase::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
     if ( m_adrX.isValid() )
     {
@@ -44,23 +44,22 @@ bool RimEnsembleCrossPlotStatisticsCase::values( const RifEclipseSummaryAddress&
         auto it           = stringToTest.find( m_adrX.vectorName() );
         if ( it != std::string::npos )
         {
-            *values = m_binnedXValues;
+            return { true, m_binnedXValues };
-            return true;
         }
     }
 
     auto quantityName = resultAddress.ensembleStatisticsVectorName();
 
     if ( quantityName == RifEclipseSummaryAddressDefines::statisticsNameP10() )
-        *values = m_p10Data;
+        return { true, m_p10Data };
     else if ( quantityName == RifEclipseSummaryAddressDefines::statisticsNameP50() )
-        *values = m_p50Data;
+        return { true, m_p50Data };
     else if ( quantityName == RifEclipseSummaryAddressDefines::statisticsNameP90() )
-        *values = m_p90Data;
+        return { true, m_p90Data };
     else if ( quantityName == RifEclipseSummaryAddressDefines::statisticsNameMean() )
-        *values = m_meanData;
+        return { true, m_meanData };
 
-    return true;
+    return { true, {} };
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -142,12 +141,10 @@ void RimEnsembleCrossPlotStatisticsCase::calculate( const std::vector<RimSummary
         {
             const std::vector<time_t>& timeSteps = reader->timeSteps( inputAddressX );
 
-            std::vector<double> valuesX;
+            auto [isXOk, valuesX] = values( inputAddressX );
-            reader->values( inputAddressX, &valuesX );
             if ( valuesX.empty() ) continue;
 
-            std::vector<double> valuesY;
+            auto [isYOk, valuesY] = reader->values( inputAddressY );
-            reader->values( inputAddressY, &valuesY );
             if ( valuesY.empty() ) continue;
 
             if ( !includeIncompleteCurves && timeSteps.size() != valuesX.size() ) continue;

ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleCrossPlotStatisticsCase.h

@@ -51,7 +51,7 @@ public:
     RiaDefines::EclipseUnitSystem unitSystem() const override;
 
     std::vector<time_t>                  timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
-    bool                values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
     std::string                          unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
 
 private:

ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleStatisticsCase.cpp

@@ -73,20 +73,20 @@ bool RimEnsembleStatisticsCase::hasMeanData() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimEnsembleStatisticsCase::values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const
+std::pair<bool, std::vector<double>> RimEnsembleStatisticsCase::values( const RifEclipseSummaryAddress& resultAddress ) const
 {
     auto quantityName = resultAddress.ensembleStatisticsVectorName();
 
     if ( quantityName == RifEclipseSummaryAddressDefines::statisticsNameP10() )
-        *values = m_p10Data;
+        return { true, m_p10Data };
     else if ( quantityName == RifEclipseSummaryAddressDefines::statisticsNameP50() )
-        *values = m_p50Data;
+        return { true, m_p50Data };
     else if ( quantityName == RifEclipseSummaryAddressDefines::statisticsNameP90() )
-        *values = m_p90Data;
+        return { true, m_p90Data };
     else if ( quantityName == RifEclipseSummaryAddressDefines::statisticsNameMean() )
-        *values = m_meanData;
+        return { true, m_meanData };
 
-    return true;
+    return { true, {} };
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -152,8 +152,7 @@ void RimEnsembleStatisticsCase::calculate( const std::vector<RimSummaryCase*>& s
         if ( reader )
         {
             const std::vector<time_t>& timeSteps = reader->timeSteps( inputAddress );
-            std::vector<double>        values;
+            auto [isOk, values]                  = reader->values( inputAddress );
-            reader->values( inputAddress, &values );
 
             if ( values.empty() ) continue;
 

ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleStatisticsCase.h

@@ -46,7 +46,7 @@ public:
     void calculate( const std::vector<RimSummaryCase*>& sumCases, const RifEclipseSummaryAddress& inputAddress, bool includeIncompleteCurves );
 
     std::vector<time_t>                  timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
-    bool                values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::pair<bool, std::vector<double>> values( const RifEclipseSummaryAddress& resultAddress ) const override;
     std::string                          unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
 
     static std::vector<RimSummaryCase*> validSummaryCases( const std::vector<RimSummaryCase*>& allSumCases,

ApplicationLibCode/ProjectDataModel/Summary/RimObjectiveFunction.cpp

@@ -123,11 +123,9 @@ double RimObjectiveFunction::value( RimSummaryCase*
                     const std::vector<time_t>& allTimeSteps           = readerInterface->timeSteps( vectorSummaryAddressDiff );
                     std::vector<size_t>        timeStepsForEvaluation = timeStepIndicesForEvaluation( allTimeSteps, timeConfig );
 
-                    std::vector<double> summaryDiffValues;
+                    auto [summaryDiffOk, summaryDiffValues]       = readerInterface->values( vectorSummaryAddressDiff );
-                    std::vector<double> summaryHistoryValues;
+                    auto [summaryHistoryOk, summaryHistoryValues] = readerInterface->values( vectorSummaryAddressHistory );
-
+                    if ( summaryDiffOk && summaryHistoryOk )
-                    if ( readerInterface->values( vectorSummaryAddressDiff, &summaryDiffValues ) &&
-                         readerInterface->values( vectorSummaryAddressHistory, &summaryHistoryValues ) )
                     {
                         const double functionValue = computeFunctionValue( summaryDiffValues, summaryHistoryValues, timeStepsForEvaluation );
 

ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCaseCollection.cpp

@@ -523,11 +523,10 @@ std::vector<std::pair<RigEnsembleParameter, double>>
 
         if ( !summaryCase->caseRealizationParameters() ) continue;
 
-        std::vector<double> values;
-
         double closestValue    = std::numeric_limits<double>::infinity();
         time_t closestTimeStep = 0;
-        if ( reader->values( address, &values ) )
+        auto [isOk, values]    = reader->values( address );
+        if ( isOk )
         {
             const std::vector<time_t>& timeSteps = reader->timeSteps( address );
             for ( size_t i = 0; i < timeSteps.size(); ++i )
@@ -967,8 +966,7 @@ void RimSummaryCaseCollection::computeMinMax( const RifEclipseSummaryAddress& ad
     {
         if ( !s->summaryReader() ) continue;
 
-        std::vector<double> values;
+        auto [isOk, values] = s->summaryReader()->values( address );
-        s->summaryReader()->values( address, &values );
         if ( values.empty() ) continue;
 
         const auto [min, max] = std::minmax_element( values.begin(), values.end() );

ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCurve.cpp

@@ -298,15 +298,13 @@ std::string RimSummaryCurve::unitNameX() const
 //--------------------------------------------------------------------------------------------------
 std::vector<double> RimSummaryCurve::valuesY() const
 {
-    std::vector<double> values;
-
     RifSummaryReaderInterface* reader = valuesSummaryReaderY();
 
-    if ( !reader ) return values;
+    if ( !reader ) return {};
 
     RifEclipseSummaryAddress addr = m_yValuesSummaryAddress()->address();
-    reader->values( addr, &values );
 
+    auto [isOk, values] = reader->values( addr );
     if ( values.empty() ) return values;
 
     RimSummaryPlot* plot         = firstAncestorOrThisOfTypeAsserted<RimSummaryPlot>();
@@ -342,18 +340,13 @@ RifEclipseSummaryAddress RimSummaryCurve::errorSummaryAddressY() const
 //--------------------------------------------------------------------------------------------------
 std::vector<double> RimSummaryCurve::errorValuesY() const
 {
-    std::vector<double> values;
-
     RifSummaryReaderInterface* reader = valuesSummaryReaderY();
-
+    if ( !reader ) return {};
-    if ( !reader ) return values;
 
     RifEclipseSummaryAddress addr = errorSummaryAddressY();
-    if ( reader->hasAddress( addr ) )
+    if ( !reader->hasAddress( addr ) ) return {};
-    {
-        reader->values( addr, &values );
-    }
 
+    auto [isOk, values] = reader->values( addr );
     return values;
 }
 
@@ -362,17 +355,17 @@ std::vector<double> RimSummaryCurve::errorValuesY() const
 //--------------------------------------------------------------------------------------------------
 std::vector<double> RimSummaryCurve::valuesX() const
 {
-    std::vector<double> values;
-
-    if ( m_xValuesSummaryCase() && m_xValuesSummaryCase()->summaryReader() )
-    {
     RifSummaryReaderInterface* reader = m_xValuesSummaryCase()->summaryReader();
+    if ( !reader ) return {};
 
     RifEclipseSummaryAddress addr = m_xValuesSummaryAddress()->address();
-        reader->values( addr, &values );
+    if ( m_xValuesSummaryCase() )
+    {
+        auto [isOk, values] = reader->values( addr );
+        return values;
     }
 
-    return values;
+    return {};
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -641,15 +634,10 @@ void RimSummaryCurve::onLoadDataAndUpdate( bool updateParentPlot )
         {
             if ( m_xValuesSummaryAddress()->address().category() == SummaryCategory::SUMMARY_ENSEMBLE_STATISTICS )
             {
-                std::vector<double> curveValuesX;
-                std::vector<double> curveValuesY;
-
                 // Read x and y values from ensemble statistics (not time steps are read)
                 RifSummaryReaderInterface* reader = m_xValuesSummaryCase()->summaryReader();
-
+                auto [isOkX, curveValuesX]        = reader->values( m_xValuesSummaryAddress->address() );
-                reader->values( m_xValuesSummaryAddress->address(), &curveValuesX );
+                auto [isOkY, curveValuesY]        = reader->values( m_yValuesSummaryAddress->address() );
-                reader->values( m_yValuesSummaryAddress->address(), &curveValuesY );
-
                 setSamplesFromXYValues( curveValuesX, curveValuesY, useLogarithmicScale );
             }
             else
@@ -696,7 +684,7 @@ void RimSummaryCurve::onLoadDataAndUpdate( bool updateParentPlot )
                     {
                         auto reader = summaryCaseY()->summaryReader();
                         errAddress  = reader->errorAddress( summaryAddressY() );
-                        reader->values( errAddress, &errValues );
+                        errValues   = reader->values( errAddress ).second;
                     }
 
                     if ( errAddress.isValid() )

ApplicationLibCode/ProjectDataModel/Summary/RimSummaryMultiPlot.cpp

@@ -944,14 +944,14 @@ void RimSummaryMultiPlot::computeAggregatedAxisRange()
 {
     auto readValues = []( RimSummaryCase* summaryCase, RifEclipseSummaryAddress addr )
     {
-        std::vector<double> values;
         if ( summaryCase && summaryCase->summaryReader() )
         {
             RifSummaryReaderInterface* reader = summaryCase->summaryReader();
-            reader->values( addr, &values );
+            auto [isOk, values]               = reader->values( addr );
+            return values;
         }
 
-        return values;
+        return std::vector<double>();
     };
 
     auto findMinMaxForSummaryCase = [readValues]( RimSummaryCase* summaryCase, RifEclipseSummaryAddress addr, bool onlyPositiveValues )

ApplicationLibCode/ProjectDataModel/Summary/RimSummaryTable.cpp

@@ -695,8 +695,7 @@ void RimSummaryTable::createTableData()
     QString    unitName;
     for ( const auto& adr : summaryAddresses )
     {
-        std::vector<double> values;
+        auto [isOk, values]                    = summaryReader->values( adr );
-        summaryReader->values( adr, &values );
         const std::vector<time_t> timeSteps    = summaryReader->timeSteps( adr );
         const QString             vectorName   = QString::fromStdString( adr.vectorName() );
         const QString             categoryName = getCategoryNameFromAddress( adr );

ApplicationLibCode/ProjectDataModelCommands/RimcSummaryCase.cpp

@@ -55,18 +55,16 @@ caf::PdmObjectHandle* RimSummaryCase_summaryVectorValues::execute()
 
     auto adr = RifEclipseSummaryAddress::fromEclipseTextAddressParseErrorTokens( m_addressString().toStdString() );
 
-    std::vector<double> values;
-
     if ( sumReader )
     {
-        bool isOk = sumReader->values( adr, &values );
+        auto [isOk, values] = sumReader->values( adr );
-        if ( !isOk )
+        if ( isOk )
         {
-            // Error message
+            return RimcDataContainerDouble::create( values );
         }
     }
 
-    return RimcDataContainerDouble::create( values );
+    return RimcDataContainerDouble::create( {} );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -210,9 +208,7 @@ caf::PdmObjectHandle* RimSummaryCase_resampleValues::execute()
 
     if ( sumReader )
     {
-        std::vector<double> values;
+        auto [isOk, values] = sumReader->values( adr );
-
-        bool isOk = sumReader->values( adr, &values );
         if ( !isOk )
         {
             // Error message

ApplicationLibCode/UnitTests/HDF5FileReader-Test.cpp

@@ -105,9 +105,7 @@ TEST( HDFTests, ReadOpmSummaryData )
     {
         if ( itemCount++ < 10 )
         {
-            std::vector<double> values;
+            auto [isOk, values] = hdf5SummaryReader.values( adr );
-            hdf5SummaryReader.values( adr, &values );
-
             totalValueCount += values.size();
         }
     }

ApplicationLibCode/UnitTests/RifSummaryDataReader-Test.cpp

@@ -45,9 +45,7 @@ TEST( DISABLED_RifSummaryDataTest, OpmCommonAllData )
             size_t i = 0;
             for ( auto adr : reader.allResultAddresses() )
             {
-                std::vector<double> values;
+                auto [isOk, values] = reader.values( adr );
-
-                reader.values( adr, &values );
                 totalValuesRead += values.size();
                 i++;
                 if ( i > maxCount ) break;
@@ -94,9 +92,7 @@ TEST( DISABLED_RifSummaryDataTest, LibEclAllData )
             size_t i = 0;
             for ( auto adr : reader.allResultAddresses() )
             {
-                std::vector<double> values;
+                auto [isOk, values] = reader.values( adr );
-
-                reader.values( adr, &values );
                 totalValuesRead += values.size();
 
                 i++;