Commit 1ea4b95e authored by Sebastian Eibl's avatar Sebastian Eibl
Browse files

[CLANG-TIDY] modernize-use-override

parent 6ffa906e
......@@ -65,7 +65,7 @@ readability-use-anyofallof
'
WarningsAsErrors: '*'
HeaderFilterRegex: ''
HeaderFilterRegex: '.*'
AnalyzeTemporaryDtors: false
...
......@@ -79,14 +79,14 @@ public:
Block( BlockForest & forest, const BlockID & id, const AABB & aabb, const uint_t level, mpi::RecvBuffer & buffer,
const std::function< uint_t ( const uint_t ) > & processMapping = std::function< uint_t ( const uint_t ) >() );
virtual ~Block() {}
~Block() override {}
void toBuffer( mpi::SendBuffer & buffer ) const;
const BlockForest & getForest() const { return forest_; }
BlockForest & getForest() { return forest_; }
const BlockID & getId() const { return id_; }
const BlockID & getId() const override { return id_; }
uint_t getProcess() const;
uint_t getLevel() const { return level_; }
......@@ -135,7 +135,7 @@ public:
protected:
bool equal( const IBlock* rhs ) const;
bool equal( const IBlock* rhs ) const override;
private:
......
......@@ -36,7 +36,7 @@ template< typename T >
class BlockDataHandling : public domain_decomposition::BlockDataHandling<T>
{
public:
virtual ~BlockDataHandling() {}
~BlockDataHandling() override {}
/// must be thread-safe !
virtual void serializeCoarseToFine( Block * const block, const BlockDataID & id, mpi::SendBuffer & buffer, const uint_t child ) = 0;
......@@ -60,19 +60,19 @@ template< typename T >
class AlwaysInitializeBlockDataHandling : public BlockDataHandling<T>
{
public:
~AlwaysInitializeBlockDataHandling() {}
~AlwaysInitializeBlockDataHandling() override {}
void serialize( IBlock * const, const BlockDataID &, mpi::SendBuffer & ) {}
void serializeCoarseToFine( Block * const, const BlockDataID &, mpi::SendBuffer &, const uint_t ) {}
void serializeFineToCoarse( Block * const, const BlockDataID &, mpi::SendBuffer & ) {}
void serialize( IBlock * const, const BlockDataID &, mpi::SendBuffer & ) override {}
void serializeCoarseToFine( Block * const, const BlockDataID &, mpi::SendBuffer &, const uint_t ) override {}
void serializeFineToCoarse( Block * const, const BlockDataID &, mpi::SendBuffer & ) override {}
T * deserialize( IBlock * const block ) { return this->initialize( block ); }
T * deserializeCoarseToFine( Block * const block ) { return this->initialize( block ); }
T * deserializeFineToCoarse( Block * const block ) { return this->initialize( block ); }
T * deserialize( IBlock * const block ) override { return this->initialize( block ); }
T * deserializeCoarseToFine( Block * const block ) override { return this->initialize( block ); }
T * deserializeFineToCoarse( Block * const block ) override { return this->initialize( block ); }
void deserialize( IBlock * const, const BlockDataID &, mpi::RecvBuffer & ) {}
void deserializeCoarseToFine( Block * const, const BlockDataID &, mpi::RecvBuffer & ) {}
void deserializeFineToCoarse( Block * const, const BlockDataID &, mpi::RecvBuffer &, const uint_t ) {}
void deserialize( IBlock * const, const BlockDataID &, mpi::RecvBuffer & ) override {}
void deserializeCoarseToFine( Block * const, const BlockDataID &, mpi::RecvBuffer & ) override {}
void deserializeFineToCoarse( Block * const, const BlockDataID &, mpi::RecvBuffer &, const uint_t ) override {}
};
......@@ -81,9 +81,9 @@ template< typename T >
class AlwaysCreateBlockDataHandling : public AlwaysInitializeBlockDataHandling<T>
{
public:
~AlwaysCreateBlockDataHandling() {}
~AlwaysCreateBlockDataHandling() override {}
T * initialize( IBlock * const /*block*/ ) {return new T();}
T * initialize( IBlock * const /*block*/ ) override {return new T();}
};
......@@ -97,7 +97,7 @@ class BlockDataHandlingWrapper : public domain_decomposition::internal::BlockDat
public:
typedef domain_decomposition::internal::BlockData BlockData;
virtual ~BlockDataHandlingWrapper() {}
~BlockDataHandlingWrapper() override {}
virtual void serializeCoarseToFine( Block * const block, const BlockDataID & id, mpi::SendBuffer & buffer, const uint_t child ) = 0;
virtual void serializeFineToCoarse( Block * const block, const BlockDataID & id, mpi::SendBuffer & buffer ) = 0;
......@@ -118,67 +118,67 @@ public:
typedef domain_decomposition::internal::BlockData BlockData;
BlockDataHandlingHelper( const shared_ptr< BlockDataHandling<T> > & dataHandling ) : dataHandling_( dataHandling ) {}
~BlockDataHandlingHelper() {}
~BlockDataHandlingHelper() override {}
BlockData * initialize( IBlock * const block )
BlockData * initialize( IBlock * const block ) override
{
WALBERLA_ASSERT_NOT_NULLPTR( block );
T * ptr = dataHandling_->initialize( block );
return ptr ? new BlockData( ptr ) : NULL;
}
void serialize( IBlock * const block, const BlockDataID & id, mpi::SendBuffer & buffer )
void serialize( IBlock * const block, const BlockDataID & id, mpi::SendBuffer & buffer ) override
{
WALBERLA_ASSERT_NOT_NULLPTR( block );
dataHandling_->serialize( block, id, buffer );
}
void serializeCoarseToFine( Block * const block, const BlockDataID & id, mpi::SendBuffer & buffer, const uint_t child )
void serializeCoarseToFine( Block * const block, const BlockDataID & id, mpi::SendBuffer & buffer, const uint_t child ) override
{
WALBERLA_ASSERT_NOT_NULLPTR( block );
dataHandling_->serializeCoarseToFine( block, id, buffer, child );
}
void serializeFineToCoarse( Block * const block, const BlockDataID & id, mpi::SendBuffer & buffer )
void serializeFineToCoarse( Block * const block, const BlockDataID & id, mpi::SendBuffer & buffer ) override
{
WALBERLA_ASSERT_NOT_NULLPTR( block );
dataHandling_->serializeFineToCoarse( block, id, buffer );
}
BlockData * deserialize( IBlock * const block )
BlockData * deserialize( IBlock * const block ) override
{
WALBERLA_ASSERT_NOT_NULLPTR( block );
T * ptr = dataHandling_->deserialize( block );
return ptr ? new BlockData( ptr ) : NULL;
}
BlockData * deserializeCoarseToFine( Block * const block )
BlockData * deserializeCoarseToFine( Block * const block ) override
{
WALBERLA_ASSERT_NOT_NULLPTR( block );
T * ptr = dataHandling_->deserializeCoarseToFine( block );
return ptr ? new BlockData( ptr ) : NULL;
}
BlockData * deserializeFineToCoarse( Block * const block )
BlockData * deserializeFineToCoarse( Block * const block ) override
{
WALBERLA_ASSERT_NOT_NULLPTR( block );
T * ptr = dataHandling_->deserializeFineToCoarse( block );
return ptr ? new BlockData( ptr ) : NULL;
}
void deserialize( IBlock * const block, const BlockDataID & id, mpi::RecvBuffer & buffer )
void deserialize( IBlock * const block, const BlockDataID & id, mpi::RecvBuffer & buffer ) override
{
WALBERLA_ASSERT_NOT_NULLPTR( block );
dataHandling_->deserialize( block, id, buffer );
}
void deserializeCoarseToFine( Block * const block, const BlockDataID & id, mpi::RecvBuffer & buffer )
void deserializeCoarseToFine( Block * const block, const BlockDataID & id, mpi::RecvBuffer & buffer ) override
{
WALBERLA_ASSERT_NOT_NULLPTR( block );
dataHandling_->deserializeCoarseToFine( block, id, buffer );
}
void deserializeFineToCoarse( Block * const block, const BlockDataID & id, mpi::RecvBuffer & buffer, const uint_t child )
void deserializeFineToCoarse( Block * const block, const BlockDataID & id, mpi::RecvBuffer & buffer, const uint_t child ) override
{
WALBERLA_ASSERT_NOT_NULLPTR( block );
dataHandling_->deserializeFineToCoarse( block, id, buffer, child );
......
......@@ -223,7 +223,7 @@ public:
BlockForest( const uint_t process, const SetupBlockForest& forest, const bool keepGlobalBlockInformation = false );
BlockForest( const uint_t process, const char* const filename, const bool broadcastFile = true, const bool keepGlobalBlockInformation = false );
~BlockForest() {}
~BlockForest() override {}
uint_t getProcess() const { return process_; }
uint_t getProcessIdBytes() const { return processIdBytes_; }
......@@ -277,45 +277,45 @@ public:
inline void getBlocks( std::vector< const Block* >& blocks, const uint_t level ) const;
inline void getBlocks( std::vector< Block* >& blocks, const uint_t level );
inline void getBlocksContainedWithinAABB( std::vector< const IBlock* >& blocks, const AABB& aabb ) const;
inline void getBlocksContainedWithinAABB( std::vector< IBlock* >& blocks, const AABB& aabb );
inline void getBlocksContainedWithinAABB( std::vector< const IBlock* >& blocks, const AABB& aabb ) const override;
inline void getBlocksContainedWithinAABB( std::vector< IBlock* >& blocks, const AABB& aabb ) override;
inline void getBlocksOverlappedByAABB( std::vector< const IBlock* >& blocks, const AABB& aabb ) const;
inline void getBlocksOverlappedByAABB( std::vector< IBlock* >& blocks, const AABB& aabb );
inline void getBlocksOverlappedByAABB( std::vector< const IBlock* >& blocks, const AABB& aabb ) const override;
inline void getBlocksOverlappedByAABB( std::vector< IBlock* >& blocks, const AABB& aabb ) override;
using BlockStorage::getBlock;
inline const Block* getBlock( const IBlockID& id ) const;
inline Block* getBlock( const IBlockID& id );
inline const Block* getBlock( const IBlockID& id ) const override;
inline Block* getBlock( const IBlockID& id ) override;
inline const Block* getBlock( const real_t x, const real_t y, const real_t z ) const;
inline Block* getBlock( const real_t x, const real_t y, const real_t z );
inline const Block* getBlock( const real_t x, const real_t y, const real_t z ) const override;
inline Block* getBlock( const real_t x, const real_t y, const real_t z ) override;
inline const Block* getRootBlock( const uint_t x, const uint_t y, const uint_t z ) const;
inline Block* getRootBlock( const uint_t x, const uint_t y, const uint_t z );
bool containsGlobalBlockInformation() const { return blockInformation_->active(); }
bool containsGlobalBlockInformation() const override { return blockInformation_->active(); }
inline void getAllBlocks( std::vector< shared_ptr< IBlockID > >& blocks ) const;
inline void getAllBlocks( std::vector< shared_ptr< IBlockID > >& blocks ) const override;
inline bool blockExists ( const real_t x, const real_t y, const real_t z ) const;
inline bool blockExistsLocally ( const real_t x, const real_t y, const real_t z ) const;
inline bool blockExistsRemotely( const real_t x, const real_t y, const real_t z ) const;
inline bool blockExists ( const real_t x, const real_t y, const real_t z ) const override;
inline bool blockExistsLocally ( const real_t x, const real_t y, const real_t z ) const override;
inline bool blockExistsRemotely( const real_t x, const real_t y, const real_t z ) const override;
inline bool blockExists ( const IBlockID& id ) const;
inline bool blockExistsLocally ( const IBlockID& id ) const;
inline bool blockExistsRemotely( const IBlockID& id ) const;
inline bool blockExists ( const IBlockID& id ) const override;
inline bool blockExistsLocally ( const IBlockID& id ) const override;
inline bool blockExistsRemotely( const IBlockID& id ) const override;
inline bool rootBlockExists ( const uint_t x, const uint_t y, const uint_t z ) const;
inline bool rootBlockExistsLocally ( const uint_t x, const uint_t y, const uint_t z ) const;
inline bool rootBlockExistsRemotely( const uint_t x, const uint_t y, const uint_t z ) const;
void getBlockID( IBlockID& id, const real_t x, const real_t y, const real_t z ) const;
void getAABB ( AABB& aabb, const IBlockID& id ) const;
void getState ( Set<SUID>& state, const IBlockID& id ) const;
void getProcessRank( uint_t& rank, const IBlockID& id ) const;
void getBlockID( IBlockID& id, const real_t x, const real_t y, const real_t z ) const override;
void getAABB ( AABB& aabb, const IBlockID& id ) const override;
void getState ( Set<SUID>& state, const IBlockID& id ) const override;
void getProcessRank( uint_t& rank, const IBlockID& id ) const override;
void getRootBlockAABB ( AABB& aabb, const uint_t x, const uint_t y, const uint_t z ) const;
void getRootBlockState ( Set<SUID>& state, const uint_t x, const uint_t y, const uint_t z ) const;
......@@ -324,7 +324,7 @@ public:
const BlockInformation & getBlockInformation() const { return *blockInformation_; }
inline uint_t getLevel( const IBlock& block ) const;
inline uint_t getLevel( const IBlock& block ) const override;
inline uint_t getLevelFromBlockId( const BlockID& id ) const;
inline uint_t getAABBFromBlockId( AABB& aabb, const BlockID& id ) const;
inline AABB getAABBFromBlockId( const BlockID& id ) const;
......@@ -338,9 +338,9 @@ public:
bool insertBuffersIntoProcessNetwork() const { return insertBuffersIntoProcessNetwork_; }
const std::vector< uint_t > & getNeighborhood() const { return neighborhood_; }
const std::vector< uint_t > & getNeighboringProcesses() const { return getNeighborhood(); }
const std::vector< uint_t > & getNeighboringProcesses() const override { return getNeighborhood(); }
std::map< uint_t, std::vector< Vector3<real_t> > > getNeighboringProcessOffsets() const;
std::map< uint_t, std::vector< Vector3<real_t> > > getNeighboringProcessOffsets() const override;
......@@ -484,7 +484,7 @@ public:
protected:
bool equal( const BlockStorage* rhs ) const;
bool equal( const BlockStorage* rhs ) const override;
void addBlockData( IBlock * const block, const BlockDataID & index, domain_decomposition::internal::BlockData * const data )
{ BlockStorage::addBlockData( block, index, data ); }
......
......@@ -283,18 +283,18 @@ public:
void removeBranchId() { WALBERLA_ASSERT_GREATER_EQUAL( getUsedBits(), uint_c(4) ); id_ >>= 3; }
uint_t getBranchId() const { WALBERLA_ASSERT_GREATER_EQUAL( getUsedBits(), uint_c(4) ); return id_ & uint_c(7); }
bool operator< ( const IBlockID& rhs ) const
bool operator< ( const IBlockID& rhs ) const override override
{ WALBERLA_ASSERT_EQUAL( dynamic_cast< const BlockID* >( &rhs ), &rhs ); return id_ < static_cast< const BlockID* >( &rhs )->id_; }
bool operator> ( const IBlockID& rhs ) const
{ WALBERLA_ASSERT_EQUAL( dynamic_cast< const BlockID* >( &rhs ), &rhs ); return id_ > static_cast< const BlockID* >( &rhs )->id_; }
bool operator==( const IBlockID& rhs ) const
bool operator==( const IBlockID& rhs ) const override override
{ WALBERLA_ASSERT_EQUAL( dynamic_cast< const BlockID* >( &rhs ), &rhs ); return id_ == static_cast< const BlockID* >( &rhs )->id_; }
bool operator!=( const IBlockID& rhs ) const
bool operator!=( const IBlockID& rhs ) const override override
{ WALBERLA_ASSERT_EQUAL( dynamic_cast< const BlockID* >( &rhs ), &rhs ); return id_ != static_cast< const BlockID* >( &rhs )->id_; }
inline IDType getID() const;
inline IDType getID() const override override;
inline std::ostream& toStream( std::ostream& os ) const;
inline std::ostream& toStream( std::ostream& os ) const override override;
void toByteArray( std::vector< uint8_t >& array, const uint_t offset, const uint_t bytes ) const { uintToByteArray( id_, array, offset, bytes ); }
......
......@@ -50,13 +50,13 @@ public:
using StructuredBlockStorage::blockExistsLocally;
using StructuredBlockStorage::blockExistsRemotely;
bool blockExists ( const Cell& cell, const uint_t level = 0 ) const;
inline bool blockExistsLocally ( const Cell& cell, const uint_t level = 0 ) const;
inline bool blockExistsRemotely( const Cell& cell, const uint_t level = 0 ) const;
bool blockExists ( const Cell& cell, const uint_t level = 0 ) const override;
inline bool blockExistsLocally ( const Cell& cell, const uint_t level = 0 ) const override;
inline bool blockExistsRemotely( const Cell& cell, const uint_t level = 0 ) const override;
void getBlockID( IBlockID& id, const Cell& cell, const uint_t level = 0 ) const;
void getBlockID( IBlockID& id, const Cell& cell, const uint_t level = 0 ) const override;
inline uint_t getLevel( const IBlock& block ) const;
inline uint_t getLevel( const IBlock& block ) const override;
using StructuredBlockStorage::getNumberOfXCells;
using StructuredBlockStorage::getNumberOfYCells;
......@@ -67,14 +67,14 @@ public:
uint_t getNumberOfYCells( const IBlock& /*block*/ ) const { return blockCells_[1]; }
uint_t getNumberOfZCells( const IBlock& /*block*/ ) const { return blockCells_[2]; }
#else
uint_t getNumberOfXCells( const IBlock& block ) const { WALBERLA_ASSERT_EQUAL( &(getBlockStorage()), &(block.getBlockStorage()) ); return blockCells_[0]; }
uint_t getNumberOfYCells( const IBlock& block ) const { WALBERLA_ASSERT_EQUAL( &(getBlockStorage()), &(block.getBlockStorage()) ); return blockCells_[1]; }
uint_t getNumberOfZCells( const IBlock& block ) const { WALBERLA_ASSERT_EQUAL( &(getBlockStorage()), &(block.getBlockStorage()) ); return blockCells_[2]; }
uint_t getNumberOfXCells( const IBlock& block ) const override { WALBERLA_ASSERT_EQUAL( &(getBlockStorage()), &(block.getBlockStorage()) ); return blockCells_[0]; }
uint_t getNumberOfYCells( const IBlock& block ) const override { WALBERLA_ASSERT_EQUAL( &(getBlockStorage()), &(block.getBlockStorage()) ); return blockCells_[1]; }
uint_t getNumberOfZCells( const IBlock& block ) const override { WALBERLA_ASSERT_EQUAL( &(getBlockStorage()), &(block.getBlockStorage()) ); return blockCells_[2]; }
#endif
using StructuredBlockStorage::getNumberOfCells;
inline uint_t getNumberOfCells( const IBlock& block, const uint_t index ) const;
inline uint_t getNumberOfCells( const IBlock& block, const uint_t index ) const override;
// direct access to all member functions which are special to of BlockForest (-> for documentation of these functions see class BlockForest)
......@@ -164,21 +164,21 @@ public:
protected:
inline bool equal( const StructuredBlockStorage* rhs ) const;
inline bool equal( const StructuredBlockStorage* rhs ) const override;
// helper class for 'StructuredBlockForest::addCellBoundingBoxesAsBlockData'
class CellBoundingBoxHandling : public AlwaysInitializeBlockDataHandling< CellInterval >
{
public:
CellBoundingBoxHandling( const StructuredBlockForest & forest ) : forest_( forest ) {}
CellInterval * initialize( IBlock * const block ) { return forest_.initializeCellBoundingBox( block ); }
CellInterval * initialize( IBlock * const block ) override { return forest_.initializeCellBoundingBox( block ); }
private:
const StructuredBlockForest & forest_;
};
friend class CellBoundingBoxHandling;
//using StructuredBlockStorage::initializeCellBoundingBox;
inline BlockDataID addCellBoundingBoxesAsBlockData( const std::string & identifier );
inline BlockDataID addCellBoundingBoxesAsBlockData( const std::string & identifier ) override;
private:
......
......@@ -39,18 +39,18 @@ public:
HandlingPackInfo( const BlockDataID & bdId, const bool assumeIdenticalFlagMapping = true, const uint_t numberOfLayers = 0 ) :
bdId_( bdId ), numberOfLayers_( numberOfLayers ), assumeIdenticalFlagMapping_( assumeIdenticalFlagMapping ) {}
~HandlingPackInfo() {}
~HandlingPackInfo() override {}
bool constantDataExchange() const { return false; }
bool threadsafeReceiving() const { return false; }
bool constantDataExchange() const override { return false; }
bool threadsafeReceiving() const override { return false; }
void unpackData( IBlock * receiver, stencil::Direction dir, mpi::RecvBuffer & buffer );
void unpackData( IBlock * receiver, stencil::Direction dir, mpi::RecvBuffer & buffer ) override;
void communicateLocal( const IBlock * sender, IBlock * receiver, stencil::Direction dir );
void communicateLocal( const IBlock * sender, IBlock * receiver, stencil::Direction dir ) override;
protected:
void packDataImpl( const IBlock * sender, stencil::Direction dir, mpi::SendBuffer & buffer ) const;
void packDataImpl( const IBlock * sender, stencil::Direction dir, mpi::SendBuffer & buffer ) const override;
......
......@@ -29,7 +29,7 @@
namespace walberla {
using std::optional;
using boost::optional;
using std::nullopt;
}
......@@ -68,56 +68,56 @@ namespace math {
public:
OpNo( const char& sign, const std::string& name, const unsigned int strength ) :
OpType( sign, name, strength ) {}
double operator() ( const double &, const double & ) { WALBERLA_ABORT( "NO OPERATION" ); return 0; }
double operator() ( const double &, const double & ) override { WALBERLA_ABORT( "NO OPERATION" ); return 0; }
};
class OpPlus : public OpType{
public:
OpPlus( const char& sign, const std::string& name, const unsigned int strength ) :
OpType( sign, name, strength ) {};
double operator() ( const double & a, const double & b ) { return a + b; }
double operator() ( const double & a, const double & b ) override { return a + b; }
};
class OpMinus : public OpType{
public:
OpMinus( const char& sign, const std::string& name, const unsigned int strength ) :
OpType( sign, name, strength ) {}
double operator() ( const double & a, const double & b ) { return a - b; }
double operator() ( const double & a, const double & b ) override { return a - b; }
};
class OpMult : public OpType{
public:
OpMult( const char& sign, const std::string& name, const unsigned int strength ) :
OpType( sign, name, strength ) {}
double operator() ( const double & a, const double & b ) { return a * b; }
double operator() ( const double & a, const double & b ) override { return a * b; }
};
class OpDiv : public OpType{
public:
OpDiv( const char& sign, const std::string& name, const unsigned int strength ) :
OpType( sign, name, strength ) {}
double operator() ( const double & a, const double & b ) { return a / b; }
double operator() ( const double & a, const double & b ) override { return a / b; }
};
class OpProd : public OpType{
public:
OpProd( const char& sign, const std::string& name, const unsigned int strength ) :
OpType( sign, name, strength ) {}
double operator() ( const double & a, const double & b ) { return pow( a, b ); }
double operator() ( const double & a, const double & b ) override { return pow( a, b ); }
};
class OpRoot : public OpType{
public:
OpRoot( const char& sign, const std::string& name, const unsigned int strength ) :
OpType( sign, name, strength ) {}
double operator() ( const double & a, const double & b ) { return pow( a, 1/b ); }
double operator() ( const double & a, const double & b ) override { return pow( a, 1/b ); }
};
class OpLog : public OpType{
public:
OpLog( const char& sign, const std::string& name, const unsigned int strength ) :
OpType( sign, name, strength ) {}
double operator() ( const double & a, const double & b ) { return log10(a) / log10(b); }
double operator() ( const double & a, const double & b ) override { return log10(a) / log10(b); }
};
......
This diff is collapsed.
......@@ -110,15 +110,15 @@ namespace internal {
KnownSizeCommunication( const MPI_Comm & communicator, int tag = 0 )
: AbstractCommunication<RecvBuffer_T, SendBuffer_T>( communicator, tag ), sending_(false), receiving_(false) {}
virtual ~KnownSizeCommunication() {}
~KnownSizeCommunication() override {}
virtual void send( MPIRank receiver, const SendBuffer_T & sendBuffer );
virtual void waitForSends();
void send( MPIRank receiver, const SendBuffer_T & sendBuffer ) override;
void waitForSends() override;
virtual void scheduleReceives ( std::map<MPIRank, ReceiveInfo> & recvInfos );
void scheduleReceives ( std::map<MPIRank, ReceiveInfo> & recvInfos ) override;
/// size field of recvInfos is expected to be valid
virtual MPIRank waitForNextReceive( std::map<MPIRank, ReceiveInfo> & recvInfos );
MPIRank waitForNextReceive( std::map<MPIRank, ReceiveInfo> & recvInfos ) override;
private:
bool sending_;
......@@ -138,15 +138,15 @@ namespace internal {
UnknownSizeCommunication( const MPI_Comm & communicator, int tag = 0 )
: AbstractCommunication<RecvBuffer_T, SendBuffer_T>( communicator, tag ), sending_(false), receiving_(false) {}
virtual ~UnknownSizeCommunication() {}
~UnknownSizeCommunication() override {}
virtual void send( MPIRank receiver, const SendBuffer_T & sendBuffer );
virtual void waitForSends();
void send( MPIRank receiver, const SendBuffer_T & sendBuffer ) override;
void waitForSends() override;
virtual void scheduleReceives( std::map<MPIRank, ReceiveInfo> & recvInfos );
void scheduleReceives( std::map<MPIRank, ReceiveInfo> & recvInfos ) override;
/// size field of recvInfos can be invalid, is filled in with the actual message size
virtual MPIRank waitForNextReceive( std::map<MPIRank, ReceiveInfo> & recvInfos );
MPIRank waitForNextReceive( std::map<MPIRank, ReceiveInfo> & recvInfos ) override;
private:
bool sending_;
......@@ -170,15 +170,15 @@ namespace internal {
UnknownSizeCommunicationIProbe( const MPI_Comm & communicator, int tag = 0 )
: AbstractCommunication<RecvBuffer_T, SendBuffer_T>( communicator, tag ), sending_(false), receiving_(false) {}
virtual ~UnknownSizeCommunicationIProbe() {}
~UnknownSizeCommunicationIProbe() override {}
virtual void send( MPIRank receiver, const SendBuffer_T & sendBuffer );
virtual void waitForSends();
void send( MPIRank receiver, const SendBuffer_T & sendBuffer ) override;
void waitForSends() override;
virtual void scheduleReceives( std::map<MPIRank, ReceiveInfo> & recvInfos );
void scheduleReceives( std::map<MPIRank, ReceiveInfo> & recvInfos ) override;
/// size field of recvInfos can be invalid, is filled in with the actual message size
virtual MPIRank waitForNextReceive( std::map<MPIRank, ReceiveInfo> & recvInfos );
MPIRank waitForNextReceive( std::map<MPIRank, ReceiveInfo> & recvInfos ) override;
private:
bool sending_;
......@@ -198,15 +198,15 @@ namespace internal {
NoMPICommunication( const MPI_Comm & communicator, int tag = 0 )
: AbstractCommunication<RecvBuffer_T, SendBuffer_T>( communicator, tag ), received_( false ) {}
virtual ~NoMPICommunication() {}
~NoMPICommunication() override {}
virtual void send( MPIRank receiver, const SendBuffer_T & sendBuffer );
virtual void waitForSends();
void send( MPIRank receiver, const SendBuffer_T & sendBuffer ) override;
void waitForSends() override;
virtual void scheduleReceives( std::map<MPIRank, ReceiveInfo> & recvInfos );
void scheduleReceives( std::map<MPIRank, ReceiveInfo> & recvInfos ) override;
/// size field of recvInfos can be invalid, is filled in with the actual message size
virtual MPIRank waitForNextReceive( std::map<MPIRank, ReceiveInfo> & recvInfos );
MPIRank waitForNextReceive( std::map<MPIRank, ReceiveInfo> & recvInfos ) override;
private:
bool received_;
......
......@@ -56,7 +56,7 @@ public:
add( object, include, exclude, identifier );
}
virtual ~SetSelectableObject() {}
~SetSelectableObject() override {}
void add( const T& object, const Set<U>& include, const Set<U>& exclude, const std::string& identifier = std::string() ) {
......@@ -73,7 +73,7 @@ private:
};