diff --git a/opm/parser/eclipse/Deck/DeckItem.cpp b/opm/parser/eclipse/Deck/DeckItem.cpp index d288ae511..c35c4f5c9 100644 --- a/opm/parser/eclipse/Deck/DeckItem.cpp +++ b/opm/parser/eclipse/Deck/DeckItem.cpp @@ -26,367 +26,211 @@ namespace Opm { - template< typename T > - class DeckTypeItem : public DeckItemBase { - public: - const std::string& name() const override; - bool defaultApplied( size_t ) const override; - bool hasValue( size_t ) const override; - size_t size() const override; +template< typename T > +std::vector< T >& DeckItem::value_ref() { + return const_cast< std::vector< T >& >( + const_cast< const DeckItem& >( *this ).value_ref< T >() + ); +} - void push_back( T ); - void push_back( T, size_t numValues ); - void push_backDefault( T ); - void push_backDummyDefault() override; +template<> +const std::vector< int >& DeckItem::value_ref< int >() const { + if( this->type != get_type< int >() ) + throw std::invalid_argument( "Item of wrong type." ); - const T& get( size_t ) const; - const std::vector< T >& getData() const; + return this->ival; +} - protected: - DeckTypeItem( const std::string&, size_t ); +template<> +const std::vector< double >& DeckItem::value_ref< double >() const { + if( this->type != get_type< double >() ) + throw std::invalid_argument( "Item of wrong type." ); - private: - std::string item_name; - std::vector< bool > dataPointDefaulted; - std::vector< T > data; - }; + return this->dval; +} - template< typename T > - class DeckItemT : public DeckTypeItem< T > { - private: - using DeckTypeItem< T >::DeckTypeItem; - std::unique_ptr< DeckItemBase > clone() const override; +template<> +const std::vector< std::string >& DeckItem::value_ref< std::string >() const { + if( this->type != get_type< std::string >() ) + throw std::invalid_argument( "Item of wrong type." ); - friend class DeckItem; - }; + return this->sval; +} - template<> - class DeckItemT< double > : public DeckTypeItem< double > { - public: - using DeckTypeItem< double >::DeckTypeItem; +DeckItem::DeckItem( const std::string& nm ) : item_name( nm ) {} - const double& getSI( size_t ) const; - const std::vector< double >& getSIData() const; +DeckItem::DeckItem( const std::string& nm, int, size_t hint ) : + type( get_type< int >() ), + item_name( nm ) +{ + this->ival.reserve( hint ); + this->defaulted.reserve( hint ); +} - void push_backDimension( const Dimension& activeDimension, - const Dimension& defaultDimension ); +DeckItem::DeckItem( const std::string& nm, double, size_t hint ) : + type( get_type< double >() ), + item_name( nm ) +{ + this->dval.reserve( hint ); + this->defaulted.reserve( hint ); +} - private: - const std::vector< double >& assertSIData() const; - std::unique_ptr< DeckItemBase > clone() const override; +DeckItem::DeckItem( const std::string& nm, std::string, size_t hint ) : + type( get_type< std::string >() ), + item_name( nm ) +{ + this->sval.reserve( hint ); + this->defaulted.reserve( hint ); +} - mutable std::vector< double > SIdata; - std::vector< Dimension > dimensions; +const std::string& DeckItem::name() const { + return this->item_name; +} - friend class DeckItem; - }; +bool DeckItem::defaultApplied( size_t index ) const { + return this->defaulted.at( index ); +} - template< typename T > static inline DeckItem::type type_to_tag(); - template<> - DeckItem::type type_to_tag< int >() { - return DeckItem::integer; +bool DeckItem::hasValue( size_t index ) const { + switch( this->type ) { + case type_tag::integer: return this->ival.size() > index; + case type_tag::fdouble: return this->dval.size() > index; + case type_tag::string: return this->sval.size() > index; + default: throw std::logic_error( "Type not set." ); } +} - template<> - DeckItem::type type_to_tag< double >() { - return DeckItem::fdouble; +size_t DeckItem::size() const { + switch( this->type ) { + case type_tag::integer: return this->ival.size(); + case type_tag::fdouble: return this->dval.size(); + case type_tag::string: return this->sval.size(); + default: throw std::logic_error( "Type not set." ); } +} - template<> - DeckItem::type type_to_tag< std::string >() { - return DeckItem::string; - } +template< typename T > +const T& DeckItem::get( size_t index ) const { + return this->value_ref< T >().at( index ); +} - static inline std::string tag_to_string( DeckItem::type x ) { - switch( x ) { - case DeckItem::type::integer: return "int"; - case DeckItem::type::string: return "std::string"; - case DeckItem::type::fdouble: return "double"; - case DeckItem::type::unknown: return "unknown"; +template< typename T > +const std::vector< T >& DeckItem::getData() const { + return this->value_ref< T >(); +} - } - return "unknown"; - } +template< typename T > +void DeckItem::push( T x, size_t n ) { + auto& val = this->value_ref< T >(); + + val.insert( val.end(), n, x ); + this->defaulted.insert( this->defaulted.end(), n, false ); +} + +void DeckItem::push_back( int x, size_t n ) { + this->push( x, n ); +} + +void DeckItem::push_back( double x, size_t n ) { + this->push( x, n ); +} + +void DeckItem::push_back( std::string x, size_t n ) { + this->push( std::move( x ), n ); +} + +template< typename T > +void DeckItem::push_default( T x ) { + auto& val = this->value_ref< T >(); + if( this->defaulted.size() != val.size() ) + throw std::logic_error("To add a value to an item, " + "no 'pseudo defaults' can be added before"); + + val.push_back( std::move( x ) ); + this->defaulted.push_back( true ); +} + +void DeckItem::push_backDefault( int x ) { + this->push_default( x ); +} + +void DeckItem::push_backDefault( double x ) { + this->push_default( x ); +} + +void DeckItem::push_backDefault( std::string x ) { + this->push_default( std::move( x ) ); +} - template< typename T > - DeckTypeItem< T >::DeckTypeItem( const std::string& nm, size_t sz ) : - DeckItemBase( type_to_tag< T >() ), - item_name( nm ) - { - this->dataPointDefaulted.reserve( sz ); - this->data.reserve( sz ); - } +void DeckItem::push_backDummyDefault() { + if( !this->defaulted.empty() ) + throw std::logic_error("Pseudo defaults can only be specified for empty items"); - template< typename T > - const std::string& DeckTypeItem< T >::name() const { - return this->item_name; - } + this->defaulted.push_back( true ); +} - template< typename T > - bool DeckTypeItem< T >::defaultApplied( size_t index ) const { - return this->dataPointDefaulted.at( index ); - } +std::string DeckItem::getTrimmedString( size_t index ) const { + return boost::algorithm::trim_copy( + this->value_ref< std::string >().at( index ) + ); +} - template< typename T > - bool DeckTypeItem< T >::hasValue( size_t index ) const { - return index < this->size(); - } +double DeckItem::getSIDouble( size_t index ) const { + return this->getSIDoubleData().at( index ); +} - template< typename T > - size_t DeckTypeItem< T >::size() const { - return this->data.size(); - } +const std::vector< double >& DeckItem::getSIDoubleData() const { + const auto& raw = this->value_ref< double >(); + // we already converted this item to SI? + if( !this->SIdata.empty() ) return this->SIdata; - template< typename T > - void DeckTypeItem< T >::push_back( T x ) { - if( this->dataPointDefaulted.size() != this->data.size() ) - throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before"); - - this->data.push_back( x ); - this->dataPointDefaulted.push_back( false ); - } - - template< typename T > - void DeckTypeItem< T >::push_backDefault( T data_arg ) { - if( this->dataPointDefaulted.size() != this->data.size() ) - throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before"); - - this->data.push_back( data_arg ); - this->dataPointDefaulted.push_back(true); - } - - template< typename T > - void DeckTypeItem< T >::push_backDummyDefault() { - if( this->dataPointDefaulted.size() != 0 ) - throw std::logic_error("Pseudo defaults can only be specified for empty items"); - - this->dataPointDefaulted.push_back( true ); - } - - template< typename T > - void DeckTypeItem< T >::push_back( T x, size_t numValues ) { - if( this->dataPointDefaulted.size() != this->data.size() ) - throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before"); - - this->data.insert( this->data.end(), numValues, x ); - this->dataPointDefaulted.insert( this->dataPointDefaulted.end(), numValues, false ); - } - - template< typename T > - const T& DeckTypeItem< T >::get( size_t index ) const { - return this->data.at( index ); - } - - template< typename T > - const std::vector< T >& DeckTypeItem< T >::getData() const { - return this->data; - } - - const double& DeckItemT< double >::getSI( size_t index ) const { - return this->assertSIData().at( index ); - } - - const std::vector< double >& DeckItemT< double >::getSIData() const { - return this->assertSIData(); - } - - void DeckItemT< double >::push_backDimension( const Dimension& activeDimension, - const Dimension& defaultDimension ) { - - if( this->size() == 0 || this->defaultApplied( this->size() - 1 ) ) - this->dimensions.push_back( defaultDimension ); - else - this->dimensions.push_back( activeDimension ); - } - - template< typename T > - std::unique_ptr< DeckItemBase > DeckItemT< T >::clone() const { - return std::unique_ptr< DeckItemBase > { new DeckItemT< T >( *this ) }; - } - - std::unique_ptr< DeckItemBase > DeckItemT< double >::clone() const { - return std::unique_ptr< DeckItemBase > { new DeckItemT< double >( *this ) }; - } - - const std::vector< double >& DeckItemT< double >::assertSIData() const { - // we already converted this item to SI? - if( !this->SIdata.empty() ) return this->SIdata; - - if( this->dimensions.empty() ) - throw std::invalid_argument("No dimension has been set for item:" + this->name() + " can not ask for SI data"); - - /* - * This is an unobservable state change - SIData is lazily converted to - * SI units, so externally the object still behaves as const - */ - const auto dim_size = dimensions.size(); - const auto sz = this->size(); - this->SIdata.resize( sz ); - - for( size_t index = 0; index < sz; index++ ) { - const auto dimIndex = index % dim_size; - this->SIdata[ index ] = this->dimensions[ dimIndex ] - .convertRawToSi( this->get( index ) ); - } - - return this->SIdata; - } - - template< typename T > - static inline DeckItemT< T >* conv( std::unique_ptr< DeckItemBase >& ptr ) { - if( ptr->type_tag == type_to_tag< T >() ) - return static_cast< DeckItemT< T >* >( ptr.get() ); - - throw std::logic_error( - "Treating item " + ptr->name() - + " as " + tag_to_string( type_to_tag< T >() ) - + ", but is " - + tag_to_string( ptr->type_tag ) ); - } - - template< typename T > - static inline - const DeckItemT< T >* conv( const std::unique_ptr< DeckItemBase >& ptr ) { - if( ptr->type_tag == type_to_tag< T >() ) - return static_cast< const DeckItemT< T >* >( ptr.get() ); - - throw std::logic_error( - "Treating item " + ptr->name() - + " as " + tag_to_string( type_to_tag< T >() ) - + ", but is " - + tag_to_string( ptr->type_tag ) ); - } - - DeckItem::DeckItem( const DeckItem& rhs ) : - ptr( rhs.ptr->clone() ) - {} - - DeckItem::DeckItem( std::unique_ptr< DeckItemBase >&& x ) : - ptr( std::move( x ) ) - {} - - template< typename T > - DeckItem DeckItem::make( const std::string& name, size_t size ) { - return DeckItem( std::unique_ptr< DeckItemBase > { new DeckItemT< T >( name, size ) } ); - } - - const std::string& DeckItem::name() const { - return this->ptr->name(); - } - - bool DeckItem::defaultApplied( size_t index ) const { - return this->ptr->defaultApplied( index ); - } - - bool DeckItem::hasValue( size_t index ) const { - return this->ptr->hasValue( index ); - } - - size_t DeckItem::size() const { - return this->ptr->size(); - } - - template< typename T > - const T& DeckItem::get( size_t index ) const { - return conv< T >( this->ptr )->get( index ); - } - - template< typename T > - const std::vector< T >& DeckItem::getData() const { - return conv< T >( this->ptr )->getData(); - } - - template< typename T > - void DeckItem::push_back( T x ) { - return conv< T >( this->ptr )->push_back( x ); - } - - template< typename T > - void DeckItem::push_back( T x, size_t n ) { - return conv< T >( this->ptr )->push_back( x, n ); - } - - template< typename T > - void DeckItem::push_backDefault( T x ) { - return conv< T >( this->ptr )->push_backDefault( x ); - } - - template<> - void DeckItem::push_back( const char* x ) { - return conv< std::string >( this->ptr )->push_back( x ); - } - - template<> - void DeckItem::push_back( const char* x, size_t n ) { - return conv< std::string >( this->ptr )->push_back( x, n ); - } - - template<> - void DeckItem::push_backDefault( const char* x ) { - return conv< std::string >( this->ptr )->push_backDefault( x ); - } - - void DeckItem::push_backDummyDefault() { - return this->ptr->push_backDummyDefault(); - } - - std::string DeckItem::getTrimmedString( size_t index ) const { - return boost::algorithm::trim_copy( - conv< std::string >( this->ptr )->get( index ) - ); - } - - double DeckItem::getSIDouble( size_t index ) const { - return conv< double >( this->ptr )->getSI( index ); - } - - const std::vector< double >& DeckItem::getSIDoubleData() const { - return conv< double >( this->ptr )->getSIData(); - } - - void DeckItem::push_backDimension( Dimension active, - Dimension def ) { - return conv< double >( this->ptr ) ->push_backDimension( active, def ); - } - - DeckItem::type DeckItem::getType() const { - return this->ptr->type_tag; - } + if( this->dimensions.empty() ) + throw std::invalid_argument("No dimension has been set for item'" + + this->name() + + "'; can not ask for SI data"); /* - * Explicit template instantiations. These must be manually maintained and - * updated with changes in DeckItem so that code is emitted. + * This is an unobservable state change - SIData is lazily converted to + * SI units, so externally the object still behaves as const */ + const auto dim_size = dimensions.size(); + const auto sz = raw.size(); + this->SIdata.resize( sz ); - template class DeckTypeItem< int >; - template class DeckTypeItem< double >; - template class DeckTypeItem< std::string >; + for( size_t index = 0; index < sz; index++ ) { + const auto dimIndex = index % dim_size; + this->SIdata[ index ] = this->dimensions[ dimIndex ] + .convertRawToSi( raw[ index ] ); + } - template class DeckItemT< int >; - template class DeckItemT< double >; - template class DeckItemT< std::string >; + return this->SIdata; +} - template DeckItem DeckItem::make< int >( const std::string&, size_t ); - template DeckItem DeckItem::make< double >( const std::string&, size_t ); - template DeckItem DeckItem::make< std::string >( const std::string&, size_t ); +void DeckItem::push_backDimension( const Dimension& active, + const Dimension& def ) { + const auto& ds = this->value_ref< double >(); + const bool dim_inactive = ds.empty() + || this->defaultApplied( ds.size() - 1 ); - template const int& DeckItem::get< int >( size_t ) const; - template const double& DeckItem::get< double >( size_t ) const; - template const std::string& DeckItem::get< std::string >( size_t ) const; + this->dimensions.push_back( dim_inactive ? def : active ); +} - template const std::vector< int >& DeckItem::getData< int >() const; - template const std::vector< double >& DeckItem::getData< double >() const; - template const std::vector< std::string >& DeckItem::getData< std::string >() const; +type_tag DeckItem::getType() const { + return this->type; +} - template void DeckItem::push_back< int >( int ); - template void DeckItem::push_back< double >( double ); - template void DeckItem::push_back< std::string >( std::string ); - template void DeckItem::push_back< int >( int, size_t ); - template void DeckItem::push_back< double >( double, size_t ); - template void DeckItem::push_back< std::string >( std::string, size_t ); - template void DeckItem::push_backDefault< int >( int ); - template void DeckItem::push_backDefault< double >( double ); - template void DeckItem::push_backDefault< std::string >( std::string ); +/* + * Explicit template instantiations. These must be manually maintained and + * updated with changes in DeckItem so that code is emitted. + */ + +template const int& DeckItem::get< int >( size_t ) const; +template const double& DeckItem::get< double >( size_t ) const; +template const std::string& DeckItem::get< std::string >( size_t ) const; + +template const std::vector< int >& DeckItem::getData< int >() const; +template const std::vector< double >& DeckItem::getData< double >() const; +template const std::vector< std::string >& DeckItem::getData< std::string >() const; } diff --git a/opm/parser/eclipse/Deck/DeckItem.hpp b/opm/parser/eclipse/Deck/DeckItem.hpp index 86c85ebb4..09a77d445 100644 --- a/opm/parser/eclipse/Deck/DeckItem.hpp +++ b/opm/parser/eclipse/Deck/DeckItem.hpp @@ -25,29 +25,18 @@ #include #include +#include namespace Opm { - class DeckItem; - class DeckItemBase; - class DeckItem { public: - DeckItem() = delete; - DeckItem( const DeckItem& ); + DeckItem() = default; + DeckItem( const std::string& ); - /* for python interop as well as queries, must be manually synchronised - * with cdeck_item.cc and opm/deck/item_type_enum.py - */ - enum type { - unknown = 0, /* this signals an error */ - integer = 1, - string = 2, - fdouble = 3 - }; - - template< typename T > - static DeckItem make( const std::string&, size_t = 1 ); + DeckItem( const std::string&, int, size_t size_hint = 8 ); + DeckItem( const std::string&, double, size_t size_hint = 8 ); + DeckItem( const std::string&, std::string, size_t size_hint = 8 ); const std::string& name() const; @@ -73,40 +62,37 @@ namespace Opm { template< typename T > const std::vector< T >& getData() const; const std::vector< double >& getSIDoubleData() const; - template< typename T > void push_back( T ); - template< typename T > void push_back( T, size_t ); - template< typename T > void push_backDefault( T ); + void push_back( int, size_t = 1 ); + void push_back( double, size_t = 1 ); + void push_back( std::string, size_t = 1 ); + void push_backDefault( int ); + void push_backDefault( double ); + void push_backDefault( std::string ); // trying to access the data of a "dummy default item" will raise an exception void push_backDummyDefault(); - void push_backDimension( Dimension /* activeDimension */, - Dimension /* defaultDimension */); + void push_backDimension( const Dimension& /* activeDimension */, + const Dimension& /* defaultDimension */); - type getType() const; + type_tag getType() const; private: - DeckItem( std::unique_ptr< DeckItemBase >&& ); - std::unique_ptr< DeckItemBase > ptr; + std::vector< double > dval; + std::vector< int > ival; + std::vector< std::string > sval; + + type_tag type = type_tag::unknown; + + std::string item_name; + std::vector< bool > defaulted; + std::vector< Dimension > dimensions; + mutable std::vector< double > SIdata; + + template< typename T > std::vector< T >& value_ref(); + template< typename T > const std::vector< T >& value_ref() const; + template< typename T > void push( T, size_t ); + template< typename T > void push_default( T ); }; - - class DeckItemBase { - public: - virtual const std::string& name() const = 0; - virtual bool defaultApplied( size_t ) const = 0; - virtual bool hasValue( size_t ) const = 0; - virtual size_t size() const = 0; - virtual void push_backDummyDefault() = 0; - virtual ~DeckItemBase() = default; - const DeckItem::type type_tag; - - protected: - DeckItemBase( DeckItem::type tag ) : type_tag( tag ) {} - - private: - virtual std::unique_ptr< DeckItemBase > clone() const = 0; - friend class DeckItem; - }; - } #endif /* DECKITEM_HPP */ diff --git a/opm/parser/eclipse/Deck/DeckRecord.cpp b/opm/parser/eclipse/Deck/DeckRecord.cpp index d2b53834b..54d67bef4 100644 --- a/opm/parser/eclipse/Deck/DeckRecord.cpp +++ b/opm/parser/eclipse/Deck/DeckRecord.cpp @@ -56,7 +56,7 @@ namespace Opm { return m_items.size(); } - void DeckRecord::addItem( DeckItem&& deckItem ) { + void DeckRecord::addItem( DeckItem deckItem ) { if( this->hasItem( deckItem.name() ) ) throw std::invalid_argument( "Item with name: " diff --git a/opm/parser/eclipse/Deck/DeckRecord.hpp b/opm/parser/eclipse/Deck/DeckRecord.hpp index 752f91c3a..4a1dc3dda 100644 --- a/opm/parser/eclipse/Deck/DeckRecord.hpp +++ b/opm/parser/eclipse/Deck/DeckRecord.hpp @@ -36,7 +36,7 @@ namespace Opm { DeckRecord( std::vector< DeckItem >&& ); size_t size() const; - void addItem( DeckItem&& deckItem ); + void addItem( DeckItem deckItem ); DeckItem& getItem( size_t index ); DeckItem& getItem( const std::string& name ); @@ -47,7 +47,7 @@ namespace Opm { const DeckItem& getDataItem() const; bool hasItem(const std::string& name) const; - + template DeckItem& getItem() { return getItem( Item::itemName ); diff --git a/opm/parser/eclipse/Deck/tests/DeckDoubleItemTests.cpp b/opm/parser/eclipse/Deck/tests/DeckDoubleItemTests.cpp index 2d8875911..d31e1350b 100644 --- a/opm/parser/eclipse/Deck/tests/DeckDoubleItemTests.cpp +++ b/opm/parser/eclipse/Deck/tests/DeckDoubleItemTests.cpp @@ -30,11 +30,11 @@ using namespace Opm; BOOST_AUTO_TEST_CASE(InitializeDouble) { - BOOST_REQUIRE_NO_THROW( DeckItem::make< double >("HEI") ); + BOOST_REQUIRE_NO_THROW( DeckItem( "HEI", double() ) ); } BOOST_AUTO_TEST_CASE(GetDoubleAtIndex_NoData_ExceptionThrown) { - auto deckDoubleItem = DeckItem::make< double >("TEST"); + DeckItem deckDoubleItem( "TEST", double() ); BOOST_CHECK_THROW(deckDoubleItem.get< double >(0), std::out_of_range); deckDoubleItem.push_back(1.89); @@ -43,7 +43,7 @@ BOOST_AUTO_TEST_CASE(GetDoubleAtIndex_NoData_ExceptionThrown) { BOOST_AUTO_TEST_CASE(sizeDouble_correct) { - auto deckDoubleItem = DeckItem::make< double >("TEST"); + DeckItem deckDoubleItem( "TEST", double() ); BOOST_CHECK_EQUAL( 0U , deckDoubleItem.size()); deckDoubleItem.push_back( 100.0 ); @@ -57,7 +57,7 @@ BOOST_AUTO_TEST_CASE(sizeDouble_correct) { BOOST_AUTO_TEST_CASE(SetInDeck) { - auto deckDoubleItem = DeckItem::make< double >("TEST"); + DeckItem deckDoubleItem( "TEST", double() ); BOOST_CHECK( deckDoubleItem.size() == 0 ); deckDoubleItem.push_backDefault( 1.0 ); @@ -74,7 +74,7 @@ BOOST_AUTO_TEST_CASE(SetInDeck) { } BOOST_AUTO_TEST_CASE(DummyDefaults) { - auto deckDoubleItem = DeckItem::make< double >("TEST"); + DeckItem deckDoubleItem( "TEST", double() ); BOOST_CHECK_EQUAL(deckDoubleItem.size(), 0); deckDoubleItem.push_backDummyDefault(); @@ -84,7 +84,7 @@ BOOST_AUTO_TEST_CASE(DummyDefaults) { } BOOST_AUTO_TEST_CASE(PushBackMultiple) { - auto item = DeckItem::make< double >("HEI"); + DeckItem item( "HEI", double() ); item.push_back(10.22 , 100 ); BOOST_CHECK_EQUAL( 100U , item.size() ); for (size_t i=0; i < 100; i++) @@ -92,7 +92,7 @@ BOOST_AUTO_TEST_CASE(PushBackMultiple) { } BOOST_AUTO_TEST_CASE(PushBackDimension) { - auto item = DeckItem::make< double >("HEI"); + DeckItem item( "HEI", double() ); Dimension activeDimension{ "Length" , 100 }; Dimension defaultDimension{ "Length" , 10 }; @@ -104,13 +104,13 @@ BOOST_AUTO_TEST_CASE(PushBackDimension) { } BOOST_AUTO_TEST_CASE(PushBackDimensionInvalidType) { - auto item = DeckItem::make< int >("HEI"); + DeckItem item( "HEI", int() ); Dimension dim{ "Length" , 100 }; BOOST_CHECK_THROW( item.push_backDimension( dim , dim ) , std::logic_error ); } BOOST_AUTO_TEST_CASE(GetSIWithoutDimensionThrows) { - auto item = DeckItem::make< double >("HEI"); + DeckItem item( "HEI", double() ); item.push_back(10.22 , 100 ); BOOST_CHECK_THROW( item.getSIDouble(0) , std::invalid_argument ); @@ -118,7 +118,7 @@ BOOST_AUTO_TEST_CASE(GetSIWithoutDimensionThrows) { } BOOST_AUTO_TEST_CASE(GetSISingleDimensionCorrect) { - auto item = DeckItem::make< double >("HEI"); + DeckItem item( "HEI", double() ); Dimension dim{ "Length" , 100 }; item.push_back(1.0 , 100 ); @@ -129,7 +129,7 @@ BOOST_AUTO_TEST_CASE(GetSISingleDimensionCorrect) { } BOOST_AUTO_TEST_CASE(GetSISingleDefault) { - auto item = DeckItem::make< double >("HEI"); + DeckItem item( "HEI", double() ); Dimension dim{ "Length" , 1 }; Dimension defaultDim{ "Length" , 100 }; @@ -141,7 +141,7 @@ BOOST_AUTO_TEST_CASE(GetSISingleDefault) { } BOOST_AUTO_TEST_CASE(GetSIMultipleDim) { - auto item = DeckItem::make< double >("HEI"); + DeckItem item( "HEI", double() ); Dimension dim1{ "Length" , 2 }; Dimension dim2{ "Length" , 4 }; Dimension dim3{ "Length" , 8 }; diff --git a/opm/parser/eclipse/Deck/tests/DeckIntItemTests.cpp b/opm/parser/eclipse/Deck/tests/DeckIntItemTests.cpp index 998582859..cf686505d 100644 --- a/opm/parser/eclipse/Deck/tests/DeckIntItemTests.cpp +++ b/opm/parser/eclipse/Deck/tests/DeckIntItemTests.cpp @@ -27,12 +27,12 @@ using namespace Opm; BOOST_AUTO_TEST_CASE(Initialize) { - BOOST_REQUIRE_NO_THROW( DeckItem::make< int >("TEST") ); + BOOST_REQUIRE_NO_THROW( DeckItem m( "TEST", int() ) ); } BOOST_AUTO_TEST_CASE(HasValue) { - auto deckIntItem = DeckItem::make< int >("TEST"); + DeckItem deckIntItem( "TEST", int() ); BOOST_CHECK_EQUAL( false , deckIntItem.hasValue(0) ); deckIntItem.push_back(1); BOOST_CHECK_EQUAL( true , deckIntItem.hasValue(0) ); @@ -40,7 +40,7 @@ BOOST_AUTO_TEST_CASE(HasValue) { } BOOST_AUTO_TEST_CASE(DummyDefaults) { - auto deckIntItem = DeckItem::make< int >("TEST"); + DeckItem deckIntItem( "TEST", int() ); BOOST_CHECK_EQUAL(deckIntItem.size(), 0); deckIntItem.push_backDummyDefault(); @@ -52,19 +52,19 @@ BOOST_AUTO_TEST_CASE(DummyDefaults) { } BOOST_AUTO_TEST_CASE(GetIntAtIndex_NoData_ExceptionThrown) { - auto deckIntItem = DeckItem::make< int >("TEST"); + DeckItem deckIntItem( "TEST", int() ); deckIntItem.push_back(100); BOOST_CHECK(deckIntItem.get< int >(0) == 100); BOOST_CHECK_THROW(deckIntItem.get< int >(1), std::out_of_range); } BOOST_AUTO_TEST_CASE(InitializeDefaultApplied) { - auto deckIntItem = DeckItem::make< int >("TEST"); + DeckItem deckIntItem( "TEST", int() ); BOOST_CHECK( deckIntItem.size() == 0 ); } BOOST_AUTO_TEST_CASE(size_correct) { - auto deckIntItem = DeckItem::make< int >("TEST"); + DeckItem deckIntItem( "TEST", int() ); BOOST_CHECK_EQUAL( 0U , deckIntItem.size()); deckIntItem.push_back( 100 ); @@ -76,7 +76,7 @@ BOOST_AUTO_TEST_CASE(size_correct) { } BOOST_AUTO_TEST_CASE(DefaultNotApplied) { - auto deckIntItem = DeckItem::make< int >("TEST"); + DeckItem deckIntItem( "TEST", int() ); BOOST_CHECK( deckIntItem.size() == 0 ); deckIntItem.push_back( 100 ); @@ -89,7 +89,7 @@ BOOST_AUTO_TEST_CASE(DefaultNotApplied) { } BOOST_AUTO_TEST_CASE(UseDefault) { - auto deckIntItem = DeckItem::make< int >("TEST"); + DeckItem deckIntItem( "TEST", int() ); deckIntItem.push_backDefault( 100 ); @@ -101,7 +101,7 @@ BOOST_AUTO_TEST_CASE(UseDefault) { } BOOST_AUTO_TEST_CASE(DefaultApplied) { - auto deckIntItem = DeckItem::make< int >("TEST"); + DeckItem deckIntItem( "TEST", int() ); BOOST_CHECK( deckIntItem.size() == 0 ); deckIntItem.push_backDefault( 100 ); @@ -117,12 +117,9 @@ BOOST_AUTO_TEST_CASE(DefaultApplied) { BOOST_AUTO_TEST_CASE(PushBackMultiple) { - auto item = DeckItem::make< int >("HEI"); + DeckItem item( "HEI", int() ); item.push_back(10 , 100U ); BOOST_CHECK_EQUAL( 100U , item.size() ); for (size_t i=0; i < 100; i++) BOOST_CHECK_EQUAL(10 , item.get< int >(i)); } - - - diff --git a/opm/parser/eclipse/Deck/tests/DeckRecordTests.cpp b/opm/parser/eclipse/Deck/tests/DeckRecordTests.cpp index 9eb7f0f07..16282ef3f 100644 --- a/opm/parser/eclipse/Deck/tests/DeckRecordTests.cpp +++ b/opm/parser/eclipse/Deck/tests/DeckRecordTests.cpp @@ -31,10 +31,6 @@ using namespace Opm; -static DeckItem mkIntItem( std::string name ) { - return DeckItem::make< int >( name ); -} - BOOST_AUTO_TEST_CASE(Initialize) { BOOST_CHECK_NO_THROW(DeckRecord deckRecord); } @@ -46,56 +42,49 @@ BOOST_AUTO_TEST_CASE(size_defaultConstructor_sizezero) { BOOST_AUTO_TEST_CASE(addItem_singleItem_sizeone) { DeckRecord deckRecord; - deckRecord.addItem( mkIntItem( "TEST" ) ); + deckRecord.addItem( DeckItem { "TEST", int() } ); BOOST_CHECK_EQUAL(1U, deckRecord.size()); } BOOST_AUTO_TEST_CASE(addItem_multipleItems_sizecorrect) { DeckRecord deckRecord; - deckRecord.addItem( mkIntItem( "TEST" ) ); - deckRecord.addItem( mkIntItem( "TEST2" ) ); - deckRecord.addItem( mkIntItem( "TEST3" ) ); + deckRecord.addItem( DeckItem { "TEST", int() } ); + deckRecord.addItem( DeckItem { "TEST2", int() } ); + deckRecord.addItem( DeckItem { "TEST3", int() } ); BOOST_CHECK_EQUAL(3U, deckRecord.size()); } -BOOST_AUTO_TEST_CASE(addItem_sameItemTwoTimes_throws) { - DeckRecord deckRecord; - auto intItem1 = mkIntItem( "TEST" ); - deckRecord.addItem( std::move( intItem1 ) ); - BOOST_CHECK_THROW(deckRecord.addItem( std::move( intItem1 ) ), std::invalid_argument); -} - BOOST_AUTO_TEST_CASE(addItem_differentItemsSameName_throws) { DeckRecord deckRecord; - deckRecord.addItem( mkIntItem( "TEST" ) ); - BOOST_CHECK_THROW( deckRecord.addItem( mkIntItem( "TEST" ) ), std::invalid_argument ); - std::vector< DeckItem > items = { mkIntItem( "TEST" ), mkIntItem( "TEST" ) }; + deckRecord.addItem( DeckItem { "TEST", int() } ); + BOOST_CHECK_THROW( deckRecord.addItem( DeckItem { "TEST", int() } ), std::invalid_argument ); + std::vector< DeckItem > items = { DeckItem { "TEST", int() }, DeckItem { "TEST" , int() } }; BOOST_CHECK_THROW( DeckRecord( std::move( items ) ), std::invalid_argument ); } BOOST_AUTO_TEST_CASE(get_byIndex_returnsItem) { DeckRecord deckRecord; - deckRecord.addItem( mkIntItem( "TEST" ) ); + deckRecord.addItem( DeckItem { "TEST", int() } ); BOOST_CHECK_NO_THROW(deckRecord.getItem(0U)); } BOOST_AUTO_TEST_CASE(get_indexoutofbounds_throws) { DeckRecord deckRecord; - deckRecord.addItem( mkIntItem( "TEST" ) ); + deckRecord.addItem( DeckItem { "TEST", int() } ); BOOST_CHECK_THROW(deckRecord.getItem(1), std::out_of_range); } BOOST_AUTO_TEST_CASE(get_byName_returnsItem) { DeckRecord deckRecord; - deckRecord.addItem( mkIntItem( "TEST" ) ); + deckRecord.addItem( DeckItem { "TEST", int() } ); deckRecord.getItem("TEST"); } BOOST_AUTO_TEST_CASE(get_byNameNonExisting_throws) { DeckRecord deckRecord; - deckRecord.addItem( mkIntItem( "TEST" ) ); + deckRecord.addItem( DeckItem { "TEST", int() } ); BOOST_CHECK_THROW(deckRecord.getItem("INVALID"), std::invalid_argument); } diff --git a/opm/parser/eclipse/Deck/tests/DeckStringItemTests.cpp b/opm/parser/eclipse/Deck/tests/DeckStringItemTests.cpp index f78b3c726..383ce0fae 100644 --- a/opm/parser/eclipse/Deck/tests/DeckStringItemTests.cpp +++ b/opm/parser/eclipse/Deck/tests/DeckStringItemTests.cpp @@ -28,12 +28,12 @@ using namespace Opm; BOOST_AUTO_TEST_CASE(InitializeString) { - auto stringItem = DeckItem::make< std::string >("TEST"); + DeckItem stringItem("TEST", std::string() ); BOOST_CHECK_EQUAL("TEST", stringItem.name()); } BOOST_AUTO_TEST_CASE(DummyDefaults) { - auto deckStringItem = DeckItem::make< std::string >("TEST"); + DeckItem deckStringItem("TEST", std::string() ); BOOST_CHECK_EQUAL(deckStringItem.size(), 0); deckStringItem.push_backDummyDefault(); @@ -43,14 +43,14 @@ BOOST_AUTO_TEST_CASE(DummyDefaults) { } BOOST_AUTO_TEST_CASE(GetStringAtIndex_NoData_ExceptionThrown) { - auto deckStringItem = DeckItem::make< std::string >("TEST"); + DeckItem deckStringItem( "TEST", std::string() ); BOOST_CHECK_THROW(deckStringItem.get< std::string >(0), std::out_of_range); deckStringItem.push_back("SA"); BOOST_CHECK_THROW(deckStringItem.get< std::string >(1), std::out_of_range); } BOOST_AUTO_TEST_CASE(size_variouspushes_sizecorrect) { - auto deckStringItem = DeckItem::make< std::string >("TEST"); + DeckItem deckStringItem( "TEST", std::string() ); BOOST_CHECK_EQUAL(0U, deckStringItem.size()); deckStringItem.push_back("WELL-3"); @@ -62,7 +62,7 @@ BOOST_AUTO_TEST_CASE(size_variouspushes_sizecorrect) { } BOOST_AUTO_TEST_CASE(DefaultNotApplied) { - auto deckStringItem = DeckItem::make< std::string >("TEST"); + DeckItem deckStringItem( "TEST", std::string() ); BOOST_CHECK( deckStringItem.size() == 0 ); deckStringItem.push_back( "FOO") ; @@ -72,7 +72,7 @@ BOOST_AUTO_TEST_CASE(DefaultNotApplied) { } BOOST_AUTO_TEST_CASE(DefaultApplied) { - auto deckStringItem = DeckItem::make< std::string >("TEST"); + DeckItem deckStringItem( "TEST", std::string() ); BOOST_CHECK( deckStringItem.size() == 0 ); deckStringItem.push_backDefault( "FOO" ); @@ -83,7 +83,7 @@ BOOST_AUTO_TEST_CASE(DefaultApplied) { BOOST_AUTO_TEST_CASE(PushBackMultiple) { - auto stringItem = DeckItem::make< std::string >("HEI"); + DeckItem stringItem( "TEST", std::string() ); stringItem.push_back("Heisann ", 100U ); BOOST_CHECK_EQUAL( 100U , stringItem.size() ); for (size_t i=0; i < 100; i++) diff --git a/opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleTests.cpp b/opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleTests.cpp index 9a7930346..52b91a742 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleTests.cpp +++ b/opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleTests.cpp @@ -249,9 +249,9 @@ static Deck deckWithGRUPTREE() { DeckKeyword gruptreeKeyword("GRUPTREE"); DeckRecord recordChildOfField; - auto itemChild1 = DeckItem::make< std::string >( "CHILD_GROUP" ); + DeckItem itemChild1( "CHILD_GROUP", std::string() ); itemChild1.push_back(std::string("BARNET")); - auto itemParent1 = DeckItem::make< std::string >( "PARENT_GROUP" ); + DeckItem itemParent1( "PARENT_GROUP", std::string() ); itemParent1.push_back(std::string("FAREN")); recordChildOfField.addItem( std::move( itemChild1 ) ); diff --git a/opm/parser/eclipse/EclipseState/Schedule/tests/TimeMapTest.cpp b/opm/parser/eclipse/EclipseState/Schedule/tests/TimeMapTest.cpp index 897ffb887..b60902b4e 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/tests/TimeMapTest.cpp +++ b/opm/parser/eclipse/EclipseState/Schedule/tests/TimeMapTest.cpp @@ -103,11 +103,11 @@ BOOST_AUTO_TEST_CASE(AddStepSizeCorrect) { BOOST_AUTO_TEST_CASE( dateFromEclipseThrowsInvalidRecord ) { Opm::DeckRecord startRecord; - auto dayItem = Opm::DeckItem::make< int >("DAY"); - auto monthItem = Opm::DeckItem::make< std::string >("MONTH"); - auto yearItem = Opm::DeckItem::make< int >("YEAR"); - auto timeItem = Opm::DeckItem::make< std::string >("TIME"); - auto extraItem = Opm::DeckItem::make< int >("EXTRA"); + Opm::DeckItem dayItem("DAY", int() ); + Opm::DeckItem monthItem("MONTH", std::string() ); + Opm::DeckItem yearItem("YEAR", int() ); + Opm::DeckItem timeItem("TIME", std::string() ); + Opm::DeckItem extraItem("EXTRA", int() ); dayItem.push_back( 10 ); yearItem.push_back(1987 ); @@ -116,19 +116,19 @@ BOOST_AUTO_TEST_CASE( dateFromEclipseThrowsInvalidRecord ) { BOOST_CHECK_THROW( Opm::TimeMap::timeFromEclipse( startRecord ) , std::invalid_argument ); - startRecord.addItem( std::move( dayItem ) ); + startRecord.addItem( dayItem ); BOOST_CHECK_THROW( Opm::TimeMap::timeFromEclipse( startRecord ) , std::invalid_argument ); - startRecord.addItem( std::move( monthItem ) ); + startRecord.addItem( monthItem ); BOOST_CHECK_THROW( Opm::TimeMap::timeFromEclipse( startRecord ) , std::invalid_argument ); - startRecord.addItem( std::move( yearItem ) ); + startRecord.addItem( yearItem ); BOOST_CHECK_THROW(Opm::TimeMap::timeFromEclipse( startRecord ) , std::invalid_argument ); - startRecord.addItem( std::move( timeItem ) ); + startRecord.addItem( timeItem ); BOOST_CHECK_NO_THROW(Opm::TimeMap::timeFromEclipse( startRecord )); - startRecord.addItem( std::move( extraItem ) ); + startRecord.addItem( extraItem ); BOOST_CHECK_THROW( Opm::TimeMap::timeFromEclipse( startRecord ) , std::invalid_argument ); } @@ -136,17 +136,17 @@ BOOST_AUTO_TEST_CASE( dateFromEclipseThrowsInvalidRecord ) { BOOST_AUTO_TEST_CASE( dateFromEclipseInvalidMonthThrows ) { Opm::DeckRecord startRecord; - auto dayItem = Opm::DeckItem::make< int >("DAY"); - auto monthItem = Opm::DeckItem::make< std::string >("MONTH"); - auto yearItem = Opm::DeckItem::make< int >("YEAR"); + Opm::DeckItem dayItem( "DAY", int() ); + Opm::DeckItem monthItem( "MONTH", std::string() ); + Opm::DeckItem yearItem( "YEAR", int() ); dayItem.push_back( 10 ); yearItem.push_back(1987 ); monthItem.push_back("XXX"); - startRecord.addItem( std::move( dayItem ) ); - startRecord.addItem( std::move( monthItem ) ); - startRecord.addItem( std::move( yearItem ) ); + startRecord.addItem( dayItem ); + startRecord.addItem( monthItem ); + startRecord.addItem( yearItem ); BOOST_CHECK_THROW( Opm::TimeMap::timeFromEclipse( startRecord ) , std::invalid_argument ); } @@ -177,10 +177,10 @@ BOOST_AUTO_TEST_CASE( timeFromEclipseCheckMonthNames ) { BOOST_AUTO_TEST_CASE( timeFromEclipseInputRecord ) { Opm::DeckRecord startRecord; - auto dayItem = Opm::DeckItem::make< int >("DAY"); - auto monthItem = Opm::DeckItem::make< std::string >("MONTH"); - auto yearItem = Opm::DeckItem::make< int >("YEAR"); - auto timeItem = Opm::DeckItem::make< std::string >("TIME"); + Opm::DeckItem dayItem( "DAY", int() ); + Opm::DeckItem monthItem( "MONTH", std::string() ); + Opm::DeckItem yearItem("YEAR", int() ); + Opm::DeckItem timeItem("TIME", std::string() ); dayItem.push_back( 10 ); yearItem.push_back( 1987 ); diff --git a/opm/parser/eclipse/EclipseState/Util/RecordVector.hpp b/opm/parser/eclipse/EclipseState/Util/RecordVector.hpp deleted file mode 100644 index d612f7728..000000000 --- a/opm/parser/eclipse/EclipseState/Util/RecordVector.hpp +++ /dev/null @@ -1,70 +0,0 @@ -/* - Copyright 2014 Statoil ASA. - - This file is part of the Open Porous Media project (OPM). - - OPM is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - OPM is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with OPM. If not, see . - */ - - -#ifndef OPM_RECORD_VECTOR_HPP -#define OPM_RECORD_VECTOR_HPP - -#include -#include - -/* - A vector like container which will return the last valid element - when the lookup index is out of range. -*/ - -namespace Opm { - -template -class RecordVector { -private: - std::vector m_data; -public: - size_t size() const { - return m_data.size(); - } - - T get(size_t index) const { - if (m_data.size() > 0) { - if (index >= m_data.size()) - return m_data.back(); - else - return m_data[index]; - } else - throw std::invalid_argument("Trying to get from empty RecordVector"); - } - - - void push_back(T value) { - m_data.push_back(value); - } - - typename std::vector::const_iterator begin() const { - return m_data.begin(); - } - - - typename std::vector::const_iterator end() const { - return m_data.end(); - } - -}; -} - -#endif diff --git a/opm/parser/eclipse/EclipseState/Util/tests/CMakeLists.txt b/opm/parser/eclipse/EclipseState/Util/tests/CMakeLists.txt index 09ccd2691..4eb844dc2 100644 --- a/opm/parser/eclipse/EclipseState/Util/tests/CMakeLists.txt +++ b/opm/parser/eclipse/EclipseState/Util/tests/CMakeLists.txt @@ -1,4 +1,4 @@ -foreach(tapp OrderedMapTests ValueTests RecordVectorTests) +foreach(tapp OrderedMapTests ValueTests) opm_add_test(run${tapp} SOURCES ${tapp}.cpp LIBRARIES opmparser ${Boost_LIBRARIES}) endforeach() diff --git a/opm/parser/eclipse/EclipseState/Util/tests/RecordVectorTests.cpp b/opm/parser/eclipse/EclipseState/Util/tests/RecordVectorTests.cpp deleted file mode 100644 index 17344dc65..000000000 --- a/opm/parser/eclipse/EclipseState/Util/tests/RecordVectorTests.cpp +++ /dev/null @@ -1,49 +0,0 @@ -/* - Copyright 2014 Statoil ASA. - - This file is part of the Open Porous Media project (OPM). - - OPM is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - OPM is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with OPM. If not, see . - */ - -#include -#include -#include - -#define BOOST_TEST_MODULE ScheduleTests -#include -#include - -#include - -BOOST_AUTO_TEST_CASE( check_empty) { - Opm::RecordVector vector; - BOOST_CHECK_EQUAL( 0U , vector.size()); - BOOST_CHECK_THROW( vector.get(0) , std::invalid_argument ); -} - - -BOOST_AUTO_TEST_CASE( check_add ) { - Opm::RecordVector vector; - vector.push_back(10); - BOOST_CHECK_EQUAL( 1U , vector.size()); - BOOST_CHECK_EQUAL( 10 , vector.get(0)); - BOOST_CHECK_EQUAL( 10 , vector.get(10)); - - vector.push_back(20); - BOOST_CHECK_EQUAL( 2U , vector.size()); - BOOST_CHECK_EQUAL( 10 , vector.get(0)); - BOOST_CHECK_EQUAL( 20 , vector.get(1)); - BOOST_CHECK_EQUAL( 20 , vector.get(10)); -} diff --git a/opm/parser/eclipse/Parser/ParserItem.hpp b/opm/parser/eclipse/Parser/ParserItem.hpp index 8cd6f9b21..19bf7a082 100644 --- a/opm/parser/eclipse/Parser/ParserItem.hpp +++ b/opm/parser/eclipse/Parser/ParserItem.hpp @@ -143,7 +143,7 @@ namespace Opm { /// NOTE: data are popped from the rawRecords deque! template DeckItem ParserItemScan(const ParserItemType * self, RawRecord& rawRecord ) { - auto deckItem = DeckItem::make< ValueType >( self->name(), rawRecord.size() ); + DeckItem deckItem( self->name(), ValueType(), rawRecord.size() ); if (self->sizeType() == ALL) { while (rawRecord.size() > 0) { diff --git a/opm/parser/eclipse/python/c_inter/cdeck_item.cc b/opm/parser/eclipse/python/c_inter/cdeck_item.cc index 4bc7f4219..97b5d1bb4 100644 --- a/opm/parser/eclipse/python/c_inter/cdeck_item.cc +++ b/opm/parser/eclipse/python/c_inter/cdeck_item.cc @@ -20,7 +20,7 @@ extern "C" { */ int deck_item_get_type( const Opm::DeckItem * item ) { - return item->getType(); + return static_cast< int >( item->getType() ); } int deck_item_iget_int( const Opm::DeckItem * item , int index) {