template <typename VectorType>
class OutputOperator : public Subscriptor
{
- OutputOperator(const OutputOperator<VectorType> &);
+ OutputOperator(const OutputOperator<VectorType> &) = delete;
public:
OutputOperator ();
/**
namespace Algorithms
{
template <typename VectorType>
- OutputOperator<VectorType>::~OutputOperator()
- {}
+ OutputOperator<VectorType>::~OutputOperator() = default;
template <typename VectorType>
OutputOperator<VectorType>::OutputOperator()
template <int dim, typename Number>
-Function<dim, Number>::~Function ()
-{}
+Function<dim, Number>::~Function () = default;
template <int dim, typename Number>
-VectorFunctionFromTensorFunction<dim, Number>::~VectorFunctionFromTensorFunction ()
-{}
+VectorFunctionFromTensorFunction<dim, Number>::~VectorFunctionFromTensorFunction () = default;
template <int dim, typename Number>
template <typename Number>
-FunctionTime<Number>::~FunctionTime()
-{}
+FunctionTime<Number>::~FunctionTime() = default;
inline
- ParallelForInteger::~ParallelForInteger ()
- {}
+ ParallelForInteger::~ParallelForInteger () = default;
+
inline
/**
* Inhibit automatic CopyConstructor.
*/
- ParameterHandler (const ParameterHandler &);
+ ParameterHandler (const ParameterHandler &) = delete;
/**
* Inhibit automatic assignment operator.
*/
- ParameterHandler &operator= (const ParameterHandler &);
+ ParameterHandler &operator= (const ParameterHandler &) = delete;
public:
/**
// and we can't use 'Point<dim,Number>::Point () = default' here.
template <int dim, typename Number>
inline
-Point<dim,Number>::Point ()
-{}
+Point<dim,Number>::Point () = default;
template <int N, typename T>
inline
-TableBase<N,T>::~TableBase ()
-{}
+TableBase<N,T>::~TableBase () = default;
template <int rank, int dim, typename Number>
-TensorFunction<rank, dim, Number>::~TensorFunction ()
-{}
+TensorFunction<rank, dim, Number>::~TensorFunction () = default;
template <int rank, int dim, typename Number>
template <int rank, int dim, typename Number>
-ConstantTensorFunction<rank, dim, Number>::~ConstantTensorFunction ()
-{}
+ConstantTensorFunction<rank, dim, Number>::~ConstantTensorFunction () = default;
template <int rank, int dim, typename Number>
template <typename T>
inline
- ThreadLocalStorage<T>::ThreadLocalStorage()
- {}
+ ThreadLocalStorage<T>::ThreadLocalStorage() = default;
template <typename T>
* Destructor. Unlock the mutex. Since this is a dummy mutex class, this
* of course does nothing.
*/
- ~ScopedLock () {}
+ ~ScopedLock () = default;
};
/**
private:
RT *value;
public:
- inline return_value () : value(nullptr) {}
+ inline return_value ()
+ : value(nullptr)
+ {}
inline RT &get () const
{
/**
* Virtual destructor.
*/
- virtual ~TimeStepping() {}
+ virtual ~TimeStepping() = default;
/**
* Purely virtual function. This function is used to advance from time @p
/**
* Virtual destructor.
*/
- virtual ~RungeKutta() {}
+ virtual ~RungeKutta() = default;
/**
* Purely virtual method used to initialize the Runge-Kutta method.
* you will want to call <code>initialize(runge_kutta_method)</code>
* before it can be used.
*/
- ExplicitRungeKutta() {}
+ ExplicitRungeKutta() = default;
/**
* Constructor. This function calls initialize(runge_kutta_method).
* set_newton_solver_parameters(unsigned int,double) need to be called
* before the object can be used.
*/
- ImplicitRungeKutta() {}
+ ImplicitRungeKutta() = default;
/**
* Constructor. This function calls initialize(runge_kutta_method) and
* set_time_adaptation_parameters(double, double, double, double, double,
* double) need to be called before the object can be used.
*/
- EmbeddedExplicitRungeKutta() {}
+ EmbeddedExplicitRungeKutta() = default;
/**
* Constructor. This function calls initialize(runge_kutta_method) and
/**
* Copy construction is forbidden.
*/
- InternalDataBase (const InternalDataBase &);
+ InternalDataBase (const InternalDataBase &) = delete;
public:
/**
namespace FETools
{
template <int dim, int spacedim>
- FEFactoryBase<dim,spacedim>::~FEFactoryBase()
- {}
+ FEFactoryBase<dim,spacedim>::~FEFactoryBase() = default;
/**
* Copy construction is forbidden.
*/
- InternalDataBase (const InternalDataBase &);
+ InternalDataBase (const InternalDataBase &) = delete;
public:
/**
* Mark the destructor virtual to allow destruction through pointers to
* the base class.
*/
- virtual ~PredicateBase () {}
+ virtual ~PredicateBase () = default;
/**
* Abstract function which in derived classes denotes the evaluation of
}
+
template <typename Number>
-BlockVector<Number>::~BlockVector ()
-{}
+BlockVector<Number>::~BlockVector () = default;
+
#ifdef DEAL_II_WITH_TRILINOS
/**
* Destructor.
*/
- virtual ~CommunicationPatternBase() {};
+ virtual ~CommunicationPatternBase() = default;
/**
* Reinitialize the communication pattern. The first argument @p
// QR-transformation cf. Stoer 1 4.8.2 (p. 191)
template <typename number>
-Householder<number>::Householder()
-{}
+Householder<number>::Householder() = default;
/**
* purposefully not implemented
*/
- MatrixBase(const MatrixBase &);
+ MatrixBase(const MatrixBase &) = delete;
/**
* purposefully not implemented
*/
- MatrixBase &operator=(const MatrixBase &);
+ MatrixBase &operator=(const MatrixBase &) = delete;
/**
* An internal array of integer values that is used to store the column
}
inline
- BlockVector::~BlockVector ()
- {}
+ BlockVector::~BlockVector () = default;
inline
/**
* Purposefully not implemented
*/
- SparseMatrix(const SparseMatrix &);
+ SparseMatrix(const SparseMatrix &) = delete;
/**
* Purposefully not implemented
*/
- SparseMatrix &operator= (const SparseMatrix &);
+ SparseMatrix &operator= (const SparseMatrix &) = delete;
/**
* Do the actual work for the respective reinit() function and the
* deliberately left as private (and undefined) to prevent accidental
* usage.
*/
- VectorBase &operator=(const VectorBase &);
+ VectorBase &operator=(const VectorBase &) = delete;
};
template <typename VectorType>
inline
-PointerMatrixBase<VectorType>::~PointerMatrixBase ()
-{}
+PointerMatrixBase<VectorType>::~PointerMatrixBase () = default;
/**
* Constructor.
*/
- AdditionalData () {}
+ AdditionalData () = default;
};
/**
internal::Vector::minimum_parallel_grain_size);
}
- ~VectorUpdatesRange() {}
+ ~VectorUpdatesRange() = default;
virtual void
apply_to_subrange (const std::size_t begin,
template <typename number>
-PreconditionBlockBase<number>::~PreconditionBlockBase ()
-{}
+PreconditionBlockBase<number>::~PreconditionBlockBase () = default;
template <typename MatrixType, typename inverse_type>
template <typename MatrixType, typename inverse_type>
-PreconditionBlock<MatrixType,inverse_type>::~PreconditionBlock ()
-{}
+PreconditionBlock<MatrixType,inverse_type>::~PreconditionBlock () = default;
template <typename MatrixType, typename inverse_type>
template <typename VectorType>
-SolverCG<VectorType>::~SolverCG ()
-{}
+SolverCG<VectorType>::~SolverCG () = default;
: last_step (last_step), last_residual(last_residual)
{}
- virtual ~NoConvergence () noexcept {}
+ virtual ~NoConvergence () noexcept = default;
virtual void print_info (std::ostream &out) const
{
template <class VectorType>
-SolverRichardson<VectorType>::~SolverRichardson()
-{}
+SolverRichardson<VectorType>::~SolverRichardson() = default;
template <class VectorType>
DEAL_II_NAMESPACE_OPEN
template <typename number>
-SparseILU<number>::SparseILU ()
-{}
+SparseILU<number>::SparseILU () = default;
template <typename number>
-SparseMatrixEZ<number>::~SparseMatrixEZ()
-{}
+SparseMatrixEZ<number>::~SparseMatrixEZ() = default;
template <typename number>
template <int dim, typename Number, int size>
inline
TensorProductMatrixSymmetricSum<dim,Number,size>
-::TensorProductMatrixSymmetricSum()
-{}
+::TensorProductMatrixSymmetricSum() = default;
inline
- Iterator::Iterator(const Iterator &i)
- :
- accessor(i.accessor)
- {}
+ Iterator::Iterator(const Iterator &i) = default;
* Destructor. Declared as virtual so that inheriting classes (which may
* manage their own memory) are destroyed correctly.
*/
- virtual ~VectorSpaceVector();
+ virtual ~VectorSpaceVector() = default;
};
/*@}*/
-
-
-
-#ifndef DOXYGEN
- // TODO we can get rid of this when we require C++11 by using '=default'
- // above
- template <typename Number>
- inline
- VectorSpaceVector<Number>::~VectorSpaceVector()
- {}
-#endif // DOXYGEN
}
DEAL_II_NAMESPACE_CLOSE
}
- DoFInfo::DoFInfo (const DoFInfo &dof_info_in)
- :
- row_starts (dof_info_in.row_starts),
- dof_indices (dof_info_in.dof_indices),
- constraint_indicator (dof_info_in.constraint_indicator),
- vector_partitioner (dof_info_in.vector_partitioner),
- constrained_dofs (dof_info_in.constrained_dofs),
- row_starts_plain_indices (dof_info_in.row_starts_plain_indices),
- plain_dof_indices (dof_info_in.plain_dof_indices),
- dimension (dof_info_in.dimension),
- n_components (dof_info_in.n_components),
- dofs_per_cell (dof_info_in.dofs_per_cell),
- dofs_per_face (dof_info_in.dofs_per_face),
- store_plain_indices (dof_info_in.store_plain_indices),
- cell_active_fe_index (dof_info_in.cell_active_fe_index),
- max_fe_index (dof_info_in.max_fe_index),
- fe_index_conversion (dof_info_in.fe_index_conversion),
- ghost_dofs (dof_info_in.ghost_dofs)
- {}
+
+ DoFInfo::DoFInfo (const DoFInfo &dof_info_in) = default;
template <int dim, typename Number>
-MatrixFree<dim,Number>::~MatrixFree()
-{}
+MatrixFree<dim,Number>::~MatrixFree() = default;
//----------------- Base operator -----------------------------
template <int dim, typename VectorType>
- Base<dim,VectorType>::~Base ()
- {
- }
+ Base<dim,VectorType>::~Base () = default;
namespace MeshWorker
{
template <int dim, int spacedim, typename Number>
- VectorDataBase<dim, spacedim, Number>::~VectorDataBase()
- {}
+ VectorDataBase<dim, spacedim, Number>::~VectorDataBase() = default;
+
template <int dim, int spacedim, typename Number>
{}
+
template <int dim, int spacedim, typename Number>
- VectorDataBase<dim, spacedim, Number>::VectorDataBase()
- {}
+ VectorDataBase<dim, spacedim, Number>::VectorDataBase() = default;
+
template <int dim, int spacedim, typename Number>
template <typename DoFHandlerType>
- DataEntryBase<DoFHandlerType>::~DataEntryBase ()
- {}
+ DataEntryBase<DoFHandlerType>::~DataEntryBase () = default;
{
struct Scratch
{
- Scratch() {}
+ Scratch() = default;
};
template <typename DoFHandlerType, typename number>
* private prevents the compiler to provide it's own, incorrect one if
* anyone chose to copy such an object.
*/
- TimeStepBase (const TimeStepBase &);
+ TimeStepBase (const TimeStepBase &) = delete;
/**
* Copy operator. I can see no reason why someone might want to use it, so I
* prevents the compiler to provide it's own, incorrect one if anyone chose
* to copy such an object.
*/
- TimeStepBase &operator = (const TimeStepBase &);
+ TimeStepBase &operator = (const TimeStepBase &) = delete;
// make the manager object a friend
friend class TimeDependent;
namespace Algorithms
{
- OperatorBase::~OperatorBase()
- {}
+ OperatorBase::~OperatorBase() = default;
+
+
void OperatorBase::notify(const Event &e)
{
notifications += e;
}
+
+
void
OperatorBase::clear_events ()
{
}
+
template <int dim>
-AutoDerivativeFunction<dim>::~AutoDerivativeFunction ()
-{}
+AutoDerivativeFunction<dim>::~AutoDerivativeFunction () = default;
DEAL_II_NAMESPACE_OPEN
-ConvergenceTable::ConvergenceTable()
-{}
+ConvergenceTable::ConvergenceTable() = default;
+
void ConvergenceTable::evaluate_convergence_rates(const std::string &data_column_key,
{}
-template <int dim, int spacedim>
-DataOutInterface<dim,spacedim>::~DataOutInterface ()
-{}
+template <int dim, int spacedim>
+DataOutInterface<dim,spacedim>::~DataOutInterface () = default;
template <int dim>
- FlowFunction<dim>::~FlowFunction()
- {}
+ FlowFunction<dim>::~FlowFunction() = default;
template <int dim>
}
+
template <int dim>
- PoisseuilleFlow<dim>::~PoisseuilleFlow()
- {}
+ PoisseuilleFlow<dim>::~PoisseuilleFlow() = default;
+
template <int dim>
{}
+
template <int dim>
- StokesCosine<dim>::~StokesCosine()
- {}
+ StokesCosine<dim>::~StokesCosine() = default;
+
template <int dim>
}
- Kovasznay::~Kovasznay()
- {}
+
+ Kovasznay::~Kovasznay() = default;
+
void Kovasznay::vector_values (
template <int dim>
-FunctionParser<dim>::~FunctionParser()
-{}
+FunctionParser<dim>::~FunctionParser() = default;
+
#ifdef DEAL_II_WITH_MUPARSER
-ParameterHandler::~ParameterHandler ()
-{}
+ParameterHandler::~ParameterHandler () = default;
-
-MultipleParameterLoop::UserClass::~UserClass ()
-{}
+MultipleParameterLoop::UserClass::~UserClass () = default;
-MultipleParameterLoop::~MultipleParameterLoop ()
-{}
+MultipleParameterLoop::~MultipleParameterLoop () = default;
- PatternBase::~PatternBase ()
- {}
+ PatternBase::~PatternBase () = default;
+
std::size_t
const char *Anything::description_init = "[Anything";
- Anything::Anything ()
- {}
+
+ Anything::Anything () = default;
const char *DirectoryName::description_init = "[DirectoryName";
- DirectoryName::DirectoryName ()
- {}
+
+ DirectoryName::DirectoryName () = default;
// inline and template functions
namespace internal
{
- TableEntry::TableEntry ()
- {}
+ TableEntry::TableEntry () = default;
double TableEntry::get_numeric_value () const
template <int dim, int spacedim>
- Triangulation<dim,spacedim>::~Triangulation ()
- {}
+ Triangulation<dim,spacedim>::~Triangulation () = default;
template <int dim, typename VectorType, typename DoFHandlerType>
- SolutionTransfer<dim, VectorType, DoFHandlerType>::~SolutionTransfer ()
- {}
+ SolutionTransfer<dim, VectorType, DoFHandlerType>::~SolutionTransfer () = default;
template <int dim, int spacedim>
-FiniteElement<dim,spacedim>::InternalDataBase::~InternalDataBase ()
-{}
+FiniteElement<dim,spacedim>::InternalDataBase::~InternalDataBase () = default;
+FiniteElement<dim,spacedim>::~FiniteElement () = default;
+
+
+
template <int dim, int spacedim>
double
FiniteElement<dim,spacedim>::shape_value (const unsigned int,
-FE_P1NC::~FE_P1NC () {}
+FE_P1NC::~FE_P1NC () = default;
template <int dim, int spacedim>
-FEValuesBase<dim,spacedim>::CellIteratorBase::~CellIteratorBase ()
-{}
+FEValuesBase<dim,spacedim>::CellIteratorBase::~CellIteratorBase () = default;
/* ---------------- classes derived from FEValuesBase<dim,spacedim>::CellIteratorBase --------- */
template <int dim, int spacedim>
-Mapping<dim, spacedim>::~Mapping ()
-{}
+Mapping<dim, spacedim>::~Mapping () = default;
template <int dim, int spacedim>
template <int dim, int spacedim>
-Mapping<dim, spacedim>::InternalDataBase::~InternalDataBase ()
-{}
+Mapping<dim, spacedim>::InternalDataBase::~InternalDataBase () = default;
DEAL_II_NAMESPACE_OPEN
template <int dim, int spacedim>
-MappingManifold<dim,spacedim>::InternalData::InternalData ()
-{}
+MappingManifold<dim,spacedim>::InternalData::InternalData () = default;
template <int dim, int spacedim>
template <int dim, int spacedim>
-MappingManifold<dim,spacedim>::MappingManifold ()
-{}
+MappingManifold<dim,spacedim>::MappingManifold () = default;
/* -------------------------- Manifold --------------------- */
template <int dim, int spacedim>
-Manifold<dim, spacedim>::~Manifold ()
-{}
+Manifold<dim, spacedim>::~Manifold () = default;
/* -------------------------- ChartManifold --------------------- */
template <int dim, int spacedim, int chartdim>
-ChartManifold<dim,spacedim,chartdim>::~ChartManifold ()
-{}
+ChartManifold<dim,spacedim,chartdim>::~ChartManifold () = default;
template <int dim, int spacedim>
-PersistentTriangulation<dim,spacedim>::~PersistentTriangulation ()
-{}
+PersistentTriangulation<dim,spacedim>::~PersistentTriangulation () = default;
template <int dim, int spacedim>
-Boundary<dim, spacedim>::~Boundary ()
-{}
+Boundary<dim, spacedim>::~Boundary () = default;
template <int dim, int spacedim>
template <int dim, int spacedim>
-StraightBoundary<dim, spacedim>::StraightBoundary ()
-{}
+StraightBoundary<dim, spacedim>::StraightBoundary () = default;
template <int dim, int spacedim>
}
template <int dim, int spacedim>
- FECollection<dim,spacedim>::FECollection ()
- {}
+ FECollection<dim,spacedim>::FECollection () = default;
{
template <int dim, int spacedim>
- MappingCollection<dim,spacedim>::MappingCollection ()
- {}
+ MappingCollection<dim,spacedim>::MappingCollection () = default;
-BlockSparsityPattern::BlockSparsityPattern ()
-{}
+BlockSparsityPattern::BlockSparsityPattern () = default;
-BlockDynamicSparsityPattern::BlockDynamicSparsityPattern ()
-{}
+BlockDynamicSparsityPattern::BlockDynamicSparsityPattern () = default;
namespace TrilinosWrappers
{
- BlockSparsityPattern::BlockSparsityPattern ()
- {}
+ BlockSparsityPattern::BlockSparsityPattern () = default;
-ChunkSparsityPattern::~ChunkSparsityPattern ()
-{}
+ChunkSparsityPattern::~ChunkSparsityPattern () = default;
-MatrixOut::~MatrixOut ()
-{}
+MatrixOut::~MatrixOut () = default;
namespace MPI
{
- BlockSparseMatrix::BlockSparseMatrix ()
- {}
+ BlockSparseMatrix::BlockSparseMatrix () = default;
- BlockSparseMatrix::~BlockSparseMatrix ()
- {}
+ BlockSparseMatrix::~BlockSparseMatrix () = default;
BlockSparseMatrix &
}
- PreconditionJacobi::PreconditionJacobi ()
- {}
+ PreconditionJacobi::PreconditionJacobi () = default;
PreconditionJacobi::PreconditionJacobi (const MatrixBase &matrix,
}
- PreconditionBlockJacobi::PreconditionBlockJacobi ()
- {}
+ PreconditionBlockJacobi::PreconditionBlockJacobi () = default;
PreconditionBlockJacobi::
{}
- PreconditionSOR::PreconditionSOR ()
- {}
+ PreconditionSOR::PreconditionSOR () = default;
PreconditionSOR::PreconditionSOR (const MatrixBase &matrix,
{}
- PreconditionSSOR::PreconditionSSOR ()
- {}
+ PreconditionSSOR::PreconditionSSOR () = default;
PreconditionSSOR::PreconditionSSOR (const MatrixBase &matrix,
{}
- PreconditionEisenstat::PreconditionEisenstat ()
- {}
+ PreconditionEisenstat::PreconditionEisenstat () = default;
PreconditionEisenstat::PreconditionEisenstat (const MatrixBase &matrix,
{}
- PreconditionICC::PreconditionICC ()
- {}
+ PreconditionICC::PreconditionICC () = default;
PreconditionICC::PreconditionICC (const MatrixBase &matrix,
{}
- PreconditionILU::PreconditionILU ()
- {}
+ PreconditionILU::PreconditionILU () = default;
PreconditionILU::PreconditionILU (const MatrixBase &matrix,
{}
- PreconditionBoomerAMG::PreconditionBoomerAMG ()
- {}
+ PreconditionBoomerAMG::PreconditionBoomerAMG () = default;
PreconditionBoomerAMG::PreconditionBoomerAMG (const MPI_Comm comm,
const AdditionalData &additional_data_)
{}
- PreconditionParaSails::PreconditionParaSails ()
- {}
+ PreconditionParaSails::PreconditionParaSails () = default;
PreconditionParaSails::PreconditionParaSails (const MatrixBase &matrix,
/* ----------------- PreconditionNone ------------------------- */
- PreconditionNone::PreconditionNone ()
- {}
+ PreconditionNone::PreconditionNone () = default;
PreconditionNone::PreconditionNone (const MatrixBase &matrix,
{}
- PreconditionLU::PreconditionLU ()
- {}
+ PreconditionLU::PreconditionLU () = default;
PreconditionLU::PreconditionLU (const MatrixBase &matrix,
- SolverBase::~SolverBase ()
- {}
+ SolverBase::~SolverBase () = default;
-SolverControl::~SolverControl()
-{}
+SolverControl::~SolverControl() = default;
}
-ReductionControl::~ReductionControl()
-{}
+ReductionControl::~ReductionControl() = default;
SolverControl::State
SolverControl (n, tolerance, m_log_history, m_log_result) {}
-IterationNumberControl::~IterationNumberControl()
-{}
+IterationNumberControl::~IterationNumberControl() = default;
SolverControl::State
-ConsecutiveControl::~ConsecutiveControl()
-{}
+ConsecutiveControl::~ConsecutiveControl() = default;
SolverControl::State
namespace TrilinosWrappers
{
- BlockSparseMatrix::BlockSparseMatrix ()
- {}
+ BlockSparseMatrix::BlockSparseMatrix () = default;
BlockSparseMatrix &
- BlockSparseMatrix::operator = (const BlockSparseMatrix &m)
- {
- BaseClass::operator = (m);
-
- return *this;
- }
+ BlockSparseMatrix::operator = (const BlockSparseMatrix &m) = default;
- BlockVector::~BlockVector ()
- {}
+ BlockVector::~BlockVector () = default;
- PreconditionBase::~PreconditionBase()
- {}
+ PreconditionBase::~PreconditionBase() = default;
- SolverBase::~SolverBase ()
- {}
+ SolverBase::~SolverBase () = default;
const double &reduction,
const Epetra_LinearProblem &linear_problem);
- virtual ~TrilinosReductionControl() {}
+ virtual ~TrilinosReductionControl() = default;
virtual bool
ResidualVectorRequired () const
- SolverDirect::~SolverDirect ()
- {}
+ SolverDirect::~SolverDirect () = default;
- SparseMatrix::~SparseMatrix ()
- {}
+ SparseMatrix::~SparseMatrix () = default;
// Destructor
- TrilinosPayload::~TrilinosPayload ()
- { }
+ TrilinosPayload::~TrilinosPayload () = default;
- SparsityPattern::~SparsityPattern ()
- {}
+ SparsityPattern::~SparsityPattern () = default;
template <int dim, int spacedim, typename number>
- LocalIntegrator<dim, spacedim, number>::~LocalIntegrator ()
- {}
+ LocalIntegrator<dim, spacedim, number>::~LocalIntegrator () = default;
template <int dim, int spacedim, typename number>
void
template <typename VectorType>
-MGTransferBase<VectorType>::~MGTransferBase()
-{}
+MGTransferBase<VectorType>::~MGTransferBase() = default;
template <typename VectorType>
-MGMatrixBase<VectorType>::~MGMatrixBase()
-{}
+MGMatrixBase<VectorType>::~MGMatrixBase() = default;
template <typename VectorType>
-MGSmootherBase<VectorType>::~MGSmootherBase()
-{}
+MGSmootherBase<VectorType>::~MGSmootherBase() = default;
template <typename VectorType>
template <typename VectorType>
-MGCoarseGridBase<VectorType>::~MGCoarseGridBase()
-{}
+MGCoarseGridBase<VectorType>::~MGCoarseGridBase() = default;
// Explicit instantiations
template <int dim, typename Number>
-MGTransferMatrixFree<dim,Number>::~MGTransferMatrixFree ()
-{}
+MGTransferMatrixFree<dim,Number>::~MGTransferMatrixFree () = default;
template <int dim, typename Number>
-MGTransferBlockMatrixFree<dim,Number>::MGTransferBlockMatrixFree ()
-{}
+MGTransferBlockMatrixFree<dim,Number>::MGTransferBlockMatrixFree () = default;
template <int dim, typename Number>
-MGTransferBlockMatrixFree<dim,Number>::~MGTransferBlockMatrixFree ()
-{}
+MGTransferBlockMatrixFree<dim,Number>::~MGTransferBlockMatrixFree () = default;
template <typename VectorType>
-MGTransferPrebuilt<VectorType>::MGTransferPrebuilt ()
-{}
+MGTransferPrebuilt<VectorType>::MGTransferPrebuilt () = default;
template <typename VectorType>
-MGTransferPrebuilt<VectorType>::~MGTransferPrebuilt ()
-{}
+MGTransferPrebuilt<VectorType>::~MGTransferPrebuilt () = default;
{}
template <typename number>
-MGTransferSelect<number>::~MGTransferSelect ()
-{}
+MGTransferSelect<number>::~MGTransferSelect () = default;
template <typename number>
template <typename number>
-MGTransferBlockSelect<number>::~MGTransferBlockSelect ()
-{}
+MGTransferBlockSelect<number>::~MGTransferBlockSelect () = default;
template <int dim, int spacedim, typename DoFHandlerType>
-DataOutStack<dim,spacedim,DoFHandlerType>::~DataOutStack ()
-{}
+DataOutStack<dim,spacedim,DoFHandlerType>::~DataOutStack () = default;
template <int dim, int spacedim, typename DoFHandlerType>
// -------------------------- DataPostprocessor ---------------------------
template <int dim>
-DataPostprocessor<dim>::~DataPostprocessor()
-{}
+DataPostprocessor<dim>::~DataPostprocessor() = default;
{
struct Scratch
{
- Scratch() {}
+ Scratch() = default;
};
struct CopyData
{
- CopyData() {}
+ CopyData() = default;
};
}
}
-TimeStepBase::~TimeStepBase ()
-{}
+TimeStepBase::~TimeStepBase () = default;