OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Use <=> operator for RifEclipseSummaryAddress

Browse Source 
* Use spaceship operator for RifEclipseSummaryAddress
* Set gcc-10 as compiler for Ubuntu 20.04
* Reorder declaration of members to get wanted sorting
This commit is contained in:
Magne Sjaastad 2023-01-30 14:53:07 +01:00 committed by GitHub
parent 234719aea3
commit f919ba6749
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 121 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.github/workflows/ResInsightWithCache.yml vendored
View File

@ -16,7 +16,7 @@ env:
concurrency:
group: build-${{ github.event.pull_request.number || github.ref }}
cancel-in-progress: true
jobs:
ResInsight-x64-buildcache:
runs-on: ${{ matrix.config.os }}
@ -137,6 +137,7 @@ jobs:
run: |
sudo apt-get update
sudo apt-get install libxkbcommon-x11-0 libgl1-mesa-dev mesa-common-dev libglfw3-dev libglu1-mesa-dev libhdf5-dev
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-10 100 --slave /usr/bin/g++ g++ /usr/bin/g++-10 --slave /usr/bin/gcov gcov /usr/bin/gcov-10
- name: Install Qt
uses: jurplel/install-qt-action@v3

235
ApplicationLibCode/FileInterface/RifEclipseSummaryAddress.cpp
View File

@ -108,6 +108,57 @@ RifEclipseSummaryAddress::RifEclipseSummaryAddress( SummaryVarCategory
m_vectorName = identifiers[INPUT_VECTOR_NAME];
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress::RifEclipseSummaryAddress( SummaryVarCategory category,
const std::string& vectorName,
int16_t regionNumber,
int16_t regionNumber2,
const std::string& groupName,
const std::string& wellName,
int16_t wellSegmentNumber,
const std::string& lgrName,
int32_t cellI,
int32_t cellJ,
int32_t cellK,
int16_t aquiferNumber,
bool isErrorResult,
int32_t id )
: m_variableCategory( category )
, m_vectorName( vectorName )
, m_regionNumber( regionNumber )
, m_regionNumber2( regionNumber2 )
, m_groupName( groupName )
, m_wellName( wellName )
, m_wellSegmentNumber( wellSegmentNumber )
, m_lgrName( lgrName )
, m_cellI( cellI )
, m_cellJ( cellJ )
, m_cellK( cellK )
, m_aquiferNumber( aquiferNumber )
, m_isErrorResult( isErrorResult )
, m_id( id )
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress::RifEclipseSummaryAddress()
: m_variableCategory( RifEclipseSummaryAddress::SUMMARY_INVALID )
, m_regionNumber( -1 )
, m_regionNumber2( -1 )
, m_wellSegmentNumber( -1 )
, m_cellI( -1 )
, m_cellJ( -1 )
, m_cellK( -1 )
, m_aquiferNumber( -1 )
, m_isErrorResult( false )
, m_id( -1 )
{
}
//--------------------------------------------------------------------------------------------------
/// Column header text format: [<ER|ERR|ERROR>:]<VECTOR>:<CATEGORY_PARAM_NAME1>[:<CATEGORY_PARAM_NAME2>][....]
//--------------------------------------------------------------------------------------------------
@ -963,190 +1014,6 @@ std::pair<int16_t, int16_t> RifEclipseSummaryAddress::regionToRegionPairFromUiTe
RiaStdStringTools::toInt16( r2r[1].trimmed().toStdString() ) );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool operator==( const RifEclipseSummaryAddress& first, const RifEclipseSummaryAddress& second )
{
if ( first.category() != second.category() ) return false;
if ( first.vectorName() != second.vectorName() ) return false;
switch ( first.category() )
{
case RifEclipseSummaryAddress::SUMMARY_REGION:
{
if ( first.regionNumber() != second.regionNumber() ) return false;
}
break;
case RifEclipseSummaryAddress::SUMMARY_REGION_2_REGION:
{
if ( first.regionNumber() != second.regionNumber() ) return false;
if ( first.regionNumber2() != second.regionNumber2() ) return false;
}
break;
case RifEclipseSummaryAddress::SUMMARY_GROUP:
{
if ( first.groupName() != second.groupName() ) return false;
}
break;
case RifEclipseSummaryAddress::SUMMARY_WELL:
{
if ( first.wellName() != second.wellName() ) return false;
}
break;
case RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION:
{
if ( first.wellName() != second.wellName() ) return false;
if ( first.cellI() != second.cellI() ) return false;
if ( first.cellJ() != second.cellJ() ) return false;
if ( first.cellK() != second.cellK() ) return false;
}
break;
case RifEclipseSummaryAddress::SUMMARY_WELL_LGR:
{
if ( first.wellName() != second.wellName() ) return false;
if ( first.lgrName() != second.lgrName() ) return false;
}
break;
case RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION_LGR:
{
if ( first.wellName() != second.wellName() ) return false;
if ( first.lgrName() != second.lgrName() ) return false;
if ( first.cellI() != second.cellI() ) return false;
if ( first.cellJ() != second.cellJ() ) return false;
if ( first.cellK() != second.cellK() ) return false;
}
break;
case RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT:
{
if ( first.wellName() != second.wellName() ) return false;
if ( first.wellSegmentNumber() != second.wellSegmentNumber() ) return false;
}
break;
case RifEclipseSummaryAddress::SUMMARY_BLOCK:
{
if ( first.cellI() != second.cellI() ) return false;
if ( first.cellJ() != second.cellJ() ) return false;
if ( first.cellK() != second.cellK() ) return false;
}
break;
case RifEclipseSummaryAddress::SUMMARY_BLOCK_LGR:
{
if ( first.lgrName() != second.lgrName() ) return false;
if ( first.cellI() != second.cellI() ) return false;
if ( first.cellJ() != second.cellJ() ) return false;
if ( first.cellK() != second.cellK() ) return false;
}
break;
case RifEclipseSummaryAddress::SUMMARY_AQUIFER:
{
if ( first.aquiferNumber() != second.aquiferNumber() ) return false;
}
break;
case RifEclipseSummaryAddress::SUMMARY_CALCULATED:
{
if ( first.id() != second.id() ) return false;
}
break;
}
if ( first.isErrorResult() != second.isErrorResult() ) return false;
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool operator!=( const RifEclipseSummaryAddress& first, const RifEclipseSummaryAddress& second )
{
return !operator==( first, second );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool operator<( const RifEclipseSummaryAddress& first, const RifEclipseSummaryAddress& second )
{
if ( first.vectorName() != second.vectorName() ) return first.vectorName() < second.vectorName();
switch ( first.category() )
{
case RifEclipseSummaryAddress::SUMMARY_REGION:
{
if ( first.regionNumber() != second.regionNumber() ) return first.regionNumber() < second.regionNumber();
}
break;
case RifEclipseSummaryAddress::SUMMARY_REGION_2_REGION:
{
if ( first.regionNumber() != second.regionNumber() ) return first.regionNumber() < second.regionNumber();
if ( first.regionNumber2() != second.regionNumber2() )
return first.regionNumber2() < second.regionNumber2();
}
break;
case RifEclipseSummaryAddress::SUMMARY_GROUP:
{
if ( first.groupName() != second.groupName() ) return first.groupName() < second.groupName();
}
break;
case RifEclipseSummaryAddress::SUMMARY_WELL:
{
if ( first.wellName() != second.wellName() ) return ( first.wellName() < second.wellName() );
}
break;
case RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION:
{
if ( first.wellName() != second.wellName() ) return ( first.wellName() < second.wellName() );
if ( first.cellI() != second.cellI() ) return ( first.cellI() < second.cellI() );
if ( first.cellJ() != second.cellJ() ) return ( first.cellJ() < second.cellJ() );
if ( first.cellK() != second.cellK() ) return ( first.cellK() < second.cellK() );
}
break;
case RifEclipseSummaryAddress::SUMMARY_WELL_LGR:
{
if ( first.wellName() != second.wellName() ) return ( first.wellName() < second.wellName() );
if ( first.lgrName() != second.lgrName() ) return ( first.lgrName() < second.lgrName() );
}
break;
case RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION_LGR:
{
if ( first.wellName() != second.wellName() ) return ( first.wellName() < second.wellName() );
if ( first.lgrName() != second.lgrName() ) return ( first.lgrName() < second.lgrName() );
if ( first.cellI() != second.cellI() ) return ( first.cellI() < second.cellI() );
if ( first.cellJ() != second.cellJ() ) return ( first.cellJ() < second.cellJ() );
if ( first.cellK() != second.cellK() ) return ( first.cellK() < second.cellK() );
}
break;
case RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT:
{
if ( first.wellName() != second.wellName() ) return ( first.wellName() < second.wellName() );
if ( first.wellSegmentNumber() != second.wellSegmentNumber() )
return ( first.wellSegmentNumber() < second.wellSegmentNumber() );
}
break;
case RifEclipseSummaryAddress::SUMMARY_BLOCK:
{
if ( first.cellI() != second.cellI() ) return ( first.cellI() < second.cellI() );
if ( first.cellJ() != second.cellJ() ) return ( first.cellJ() < second.cellJ() );
if ( first.cellK() != second.cellK() ) return ( first.cellK() < second.cellK() );
}
break;
case RifEclipseSummaryAddress::SUMMARY_BLOCK_LGR:
{
if ( first.lgrName() != second.lgrName() ) return ( first.lgrName() < second.lgrName() );
if ( first.cellI() != second.cellI() ) return ( first.cellI() < second.cellI() );
if ( first.cellJ() != second.cellJ() ) return ( first.cellJ() < second.cellJ() );
if ( first.cellK() != second.cellK() ) return ( first.cellK() < second.cellK() );
}
break;
case RifEclipseSummaryAddress::SUMMARY_AQUIFER:
{
if ( first.aquiferNumber() != second.aquiferNumber() )
return first.aquiferNumber() < second.aquiferNumber();
}
break;
}
if ( first.isErrorResult() != second.isErrorResult() ) return first.isErrorResult() < second.isErrorResult();
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

51
ApplicationLibCode/FileInterface/RifEclipseSummaryAddress.h
View File

@ -75,19 +75,7 @@ public:
};
public:
RifEclipseSummaryAddress()
: m_variableCategory( RifEclipseSummaryAddress::SUMMARY_INVALID )
, m_regionNumber( -1 )
, m_regionNumber2( -1 )
, m_wellSegmentNumber( -1 )
, m_cellI( -1 )
, m_cellJ( -1 )
, m_cellK( -1 )
, m_aquiferNumber( -1 )
, m_isErrorResult( false )
, m_id( -1 )
{
}
RifEclipseSummaryAddress();
RifEclipseSummaryAddress( SummaryVarCategory category,
const std::string& vectorName,
@ -102,23 +90,7 @@ public:
int32_t cellK,
int16_t aquiferNumber,
bool isErrorResult,
int32_t id )
: m_variableCategory( category )
, m_vectorName( vectorName )
, m_regionNumber( regionNumber )
, m_regionNumber2( regionNumber2 )
, m_groupName( groupName )
, m_wellName( wellName )
, m_wellSegmentNumber( wellSegmentNumber )
, m_lgrName( lgrName )
, m_cellI( cellI )
, m_cellJ( cellJ )
, m_cellK( cellK )
, m_aquiferNumber( aquiferNumber )
, m_isErrorResult( isErrorResult )
, m_id( id )
{
}
int32_t id );
RifEclipseSummaryAddress( SummaryVarCategory category, std::map<SummaryIdentifierType, std::string>& identifiers );
@ -208,6 +180,8 @@ public:
static std::string baseVectorName( const std::string& vectorName );
auto operator<=>( const RifEclipseSummaryAddress& rhs ) const = default;
private:
static RifEclipseSummaryAddress fromTokens( const std::vector<std::string>& tokens );
@ -216,27 +190,26 @@ private:
std::string formatUiTextRegionToRegion() const;
std::pair<int16_t, int16_t> regionToRegionPairFromUiText( const std::string& s );
private:
// The ordering the variables are defined in defines how the objects get sorted. Members defined first will be
// evaluated first. This concept is used by <=> operator.
SummaryVarCategory m_variableCategory;
std::string m_vectorName;
std::string m_groupName;
std::string m_wellName;
std::string m_groupName;
std::string m_lgrName;
int32_t m_cellI;
int32_t m_cellJ;
int32_t m_cellK;
int32_t m_cellJ;
int32_t m_cellI;
int16_t m_regionNumber;
int16_t m_regionNumber2;
int16_t m_wellSegmentNumber;
int16_t m_aquiferNumber;
SummaryVarCategory m_variableCategory;
bool m_isErrorResult;
int32_t m_id;
};
bool operator==( const RifEclipseSummaryAddress& first, const RifEclipseSummaryAddress& second );
bool operator!=( const RifEclipseSummaryAddress& first, const RifEclipseSummaryAddress& second );
bool operator<( const RifEclipseSummaryAddress& first, const RifEclipseSummaryAddress& second );
QTextStream& operator<<( QTextStream& str, const RifEclipseSummaryAddress& sobj );
QTextStream& operator>>( QTextStream& str, RifEclipseSummaryAddress& sobj );

56
ApplicationLibCode/UnitTests/RifEclipseSummaryAddress-Test.cpp
View File

@ -3,6 +3,9 @@
#include "RifEclipseSummaryAddress.h"
#include <QString>
#include <algorithm>
#include <random>
#include <string>
//--------------------------------------------------------------------------------------------------
@ -323,3 +326,56 @@ TEST( RifEclipseSummaryAddressTest, TestQuantityNameManipulations )
EXPECT_EQ( "FCMIT", s );
}
}
TEST( RifEclipseSummaryAddressTest, LogicalOperators )
{
// The <=> operator will compare individual members variables by the order of their declaration.
auto field_a = RifEclipseSummaryAddress::fieldAddress( "A" );
auto field_b = RifEclipseSummaryAddress::fieldAddress( "B" );
auto field_c = RifEclipseSummaryAddress::fieldAddress( "C" );
// Sort by vector name, then by number
auto aq_a = RifEclipseSummaryAddress::aquiferAddress( "A", 1 );
auto aq_b = RifEclipseSummaryAddress::aquiferAddress( "B", 1 );
auto aq_c = RifEclipseSummaryAddress::aquiferAddress( "A", 2 );
// Sort order is K, J, I
auto block_a = RifEclipseSummaryAddress::blockAddress( "A", 1, 1, 1 );
auto block_b = RifEclipseSummaryAddress::blockAddress( "A", 2, 1, 1 );
auto block_c = RifEclipseSummaryAddress::blockAddress( "A", 1, 1, 2 );
auto block_d = RifEclipseSummaryAddress::blockAddress( "A", 2, 1, 2 );
std::vector<RifEclipseSummaryAddress> addresses;
addresses.push_back( field_a );
addresses.push_back( field_b );
addresses.push_back( field_c );
addresses.push_back( aq_a );
addresses.push_back( aq_b );
addresses.push_back( aq_c );
addresses.push_back( block_a );
addresses.push_back( block_b );
addresses.push_back( block_c );
addresses.push_back( block_d );
std::random_device rd;
std::mt19937 g( rd() );
std::shuffle( addresses.begin(), addresses.end(), g );
std::sort( addresses.begin(), addresses.end() );
EXPECT_TRUE( addresses.at( 0 ) == field_a );
EXPECT_TRUE( addresses.at( 1 ) == field_b );
EXPECT_TRUE( addresses.at( 2 ) == field_c );
EXPECT_TRUE( addresses.at( 3 ) == aq_a );
EXPECT_TRUE( addresses.at( 4 ) == aq_c );
EXPECT_TRUE( addresses.at( 5 ) == aq_b );
EXPECT_TRUE( addresses.at( 6 ) == block_a );
EXPECT_TRUE( addresses.at( 7 ) == block_b );
EXPECT_TRUE( addresses.at( 8 ) == block_c );
EXPECT_TRUE( addresses.at( 9 ) == block_d );
}