*/
AlignedVector (const AlignedVector<T> &vec);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move constructor. Create a new aligned vector by stealing the contents of
* @p vec.
- *
- * @note This constructor is only available if deal.II is built with C++11.
*/
AlignedVector (AlignedVector<T> &&vec);
-#endif
/**
* Assignment to the input vector @p vec.
AlignedVector &
operator = (const AlignedVector<T> &vec);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move assignment operator.
- *
- * @note This operator is only available if deal.II is built with C++11.
*/
AlignedVector &
operator = (AlignedVector<T> &&vec);
-#endif
/**
* Change the size of the vector. It keeps old elements previously available
-#ifdef DEAL_II_WITH_CXX11
template < class T >
inline
AlignedVector<T>::AlignedVector (AlignedVector<T> &&vec)
vec._end_data = nullptr;
vec._end_allocated = nullptr;
}
-#endif
-#ifdef DEAL_II_WITH_CXX11
template < class T >
inline
AlignedVector<T> &
return *this;
}
-#endif
#endif
-/**
- * BOOST can falsely detect cxx11 support and will try to use
- * variadic templates even when we disable cxx11. This would create
- * a ton of warnings, so we tell boost to not use them in this case.
- */
-#ifndef DEAL_II_WITH_CXX11
-#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
-#endif
-
-
/***********************************************************************
* Final inclusions:
*/
*/
explicit IndexSet (const size_type size);
-#ifdef DEAL_II_WITH_CXX11
/**
* Copy constructor.
*/
* the current one.
*/
IndexSet &operator= (IndexSet &&is);
-#endif
#ifdef DEAL_II_WITH_TRILINOS
/**
-#ifdef DEAL_II_WITH_CXX11
-
inline
IndexSet::IndexSet (IndexSet &&is)
:
}
+
inline
IndexSet &IndexSet::operator= (IndexSet &&is)
{
return *this;
}
-#endif
inline
*/
Quadrature (const Quadrature<dim> &q);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move constructor. Construct a new quadrature object by transferring the
* internal data of another quadrature object.
- *
- * @note this constructor is only available if deal.II is configured with
- * C++11 support.
*/
Quadrature (Quadrature<dim> &&) = default;
-#endif
/**
* Construct a quadrature formula from given vectors of quadrature points
const double alpha = 1,
const bool factor_out_singular_weight=false);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move constructor. We cannot rely on the move constructor for `Quadrature`,
* since it does not know about the additional member `fraction` of this class.
*/
QGaussLogR(QGaussLogR<dim> &&) = default;
-#endif
protected:
/**
QGaussRadauChebyshev(const unsigned int n,
EndPoint ep=QGaussRadauChebyshev::left);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move constructor. We cannot rely on the move constructor for `Quadrature`,
* since it does not know about the additional member `ep` of this class.
*/
QGaussRadauChebyshev(QGaussRadauChebyshev<dim> &&) = default;
-#endif
private:
const EndPoint ep;
#ifndef dealii__quadrature_point_data_h
#define dealii__quadrature_point_data_h
-// must include config before checking for DEAL_II_WITH_CXX11
#include <deal.II/base/config.h>
-#ifdef DEAL_II_WITH_CXX11
-
#include <deal.II/base/quadrature.h>
#include <deal.II/base/subscriptor.h>
#include <deal.II/grid/tria.h>
* For this reason, this class may not be sufficiently flexible when, for example,
* adopting a level-set approach to describe material behavior.
*
- * @note This class is only available if deal.II is configured with C++11 support.
- *
* @author Denis Davydov, Jean-Paul Pelteret, 2016
*/
template <typename CellIteratorType, typename DataType>
#endif // DOXYGEN
DEAL_II_NAMESPACE_CLOSE
-#endif // CXX11
-
#endif
DEAL_II_NAMESPACE_OPEN
// In boost, the placeholders _1, _2, ... are in the global namespace. In
// C++11, they are in namespace std::placeholders, which makes them awkward to
-// use. Import them into the dealii::std_cxx11 namespace instead and do them
+// use. Import them into the dealii::std_cxx11 namespace instead and do the
// same below if we use boost instead. Namespace 'placeholders' is also defined
// in dealii::std_cxx11 namespace to make code C++ standard compatible.
// That is to say, if std::something works with C++11 standard,
*/
Subscriptor(const Subscriptor &);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move constructor.
*
* objects are subscribing to it.
*/
Subscriptor(Subscriptor &&);
-#endif
/**
* Destructor, asserting that the counter is zero.
*/
Subscriptor &operator = (const Subscriptor &);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move assignment operator.
*
* Asserts that the counter for the moved object is zero.
*/
Subscriptor &operator = (Subscriptor &&);
-#endif
/**
* Subscribes a user of the object. The subscriber may be identified by text
}
-#ifndef DEAL_II_WITH_CXX11
-
-template <typename T, typename U, int rank, int dim>
-struct ProductType<T,SymmetricTensor<rank,dim,U> >
-{
- typedef SymmetricTensor<rank,dim,typename ProductType<T,U>::type> type;
-};
-
-template <typename T, typename U, int rank, int dim>
-struct ProductType<SymmetricTensor<rank,dim,T>,U>
-{
- typedef SymmetricTensor<rank,dim,typename ProductType<T,U>::type> type;
-};
-
-#endif
-
-
/**
* Multiplication of a symmetric tensor with a scalar number from the right.
template <typename T2>
TableBase (const TableBase<N,T2> &src);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move constructor. Transfers the contents of another Table.
- *
- * @note This constructor is only available if deal.II is built with C++11.
*/
TableBase (TableBase<N,T> &&src);
-#endif
/**
* Destructor. Free allocated memory.
template<typename T2>
TableBase<N,T> &operator = (const TableBase<N,T2> &src);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move assignment operator. Transfer all elements of <tt>src</tt> into the
* table.
- *
- * @note This operator is only available if deal.II is built with C++11.
*/
TableBase<N,T> &operator = (TableBase<N,T> &&src);
-#endif
/**
* Test for equality of two tables.
-#ifdef DEAL_II_WITH_CXX11
-
template <int N, typename T>
TableBase<N,T>::TableBase (TableBase<N,T> &&src)
:
src.table_size = TableIndices<N>();
}
-#endif
-
template <int N, typename T>
-#ifdef DEAL_II_WITH_CXX11
-
template <int N, typename T>
inline
TableBase<N,T> &
return *this;
}
-#endif
-
template <int N, typename T>
//@{
-#ifndef DEAL_II_WITH_CXX11
-template <typename T, typename U, int rank, int dim>
-struct ProductType<T,Tensor<rank,dim,U> >
-{
- typedef Tensor<rank,dim,typename ProductType<T,U>::type> type;
-};
-
-template <typename T, typename U, int rank, int dim>
-struct ProductType<Tensor<rank,dim,T>,U>
-{
- typedef Tensor<rank,dim,typename ProductType<T,U>::type> type;
-};
-#endif
-
-
-
/**
* Scalar multiplication of a tensor of rank 0 with an object from the left.
*
}
+
/**
* Scalar multiplication of a tensor of rank 0 with an object from the right.
*
internal::ReorderedIndexView<index, rank, T>
reordered_index_view(T &t)
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(0 <= index && index < rank,
"The specified index must lie within the range [0,rank)");
-#endif
return internal::ReorderedIndexView<index, rank, T>(t);
}
inline DEAL_II_ALWAYS_INLINE
void contract(T1 &result, const T2 &left, const T3 &right)
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(rank_1 >= no_contr, "The rank of the left tensor must be "
"equal or greater than the number of "
"contractions");
static_assert(rank_2 >= no_contr, "The rank of the right tensor must be "
"equal or greater than the number of "
"contractions");
-#endif
internal::Contract<no_contr, rank_1, rank_2, dim>::template contract<T1, T2, T3>
(result, left, right);
}
-#ifdef DEAL_II_WITH_CXX11
/**
* Overload of the new_thread() function for objects that can be called like a
return Thread<return_type>(std::function<return_type ()>(function_object));
}
-#endif
/**
}
-#ifdef DEAL_II_WITH_CXX11
/**
* Overload of the new_task function for objects that can be called like a
return Task<return_type>(std::function<return_type ()>(function_object));
}
-#endif
+
/**
* Overload of the new_task function for non-member or static member
-#ifndef DEAL_II_WITH_CXX11
-// Specify the types for the implemented multiplications explicitly
-
-template <typename Number>
-struct ProductType<Number, VectorizedArray<Number> >
-{
- typedef VectorizedArray<Number> type;
-};
-
-template <typename Number>
-struct ProductType<VectorizedArray<Number>, Number>
-{
- typedef VectorizedArray<Number> type;
-};
-
-// In contrast to scalar types for which the product of a float and a double
-// variable would be a double variable, the implemented type here really is
-// VectorizedArray<float>. Since VectorizedArray<double> is only half as
-// wide as VectorizedArray<float>, we would have to throw away half of the
-// vector otherwise.
-template<>
-struct ProductType<double, VectorizedArray<float> >
-{
- typedef VectorizedArray<float> type;
-};
-
-template<>
-struct ProductType<VectorizedArray<float>, double>
-{
- typedef VectorizedArray<float> type;
-};
-#endif
-
-
-
/**
* This generic class defines a unified interface to a vectorized data type.
* For general template arguments, this class simply corresponds to the
MGInterfaceOperator<OperatorType>::vmult (VectorType &dst,
const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
#ifndef DEAL_II_MSVC
static_assert (std::is_same<typename VectorType::value_type,value_type>::value,
"The vector type must be based on the same value type as this"
"operator");
-#endif
#endif
Assert(mf_base_operator != NULL,
MGInterfaceOperator<OperatorType>::Tvmult (VectorType &dst,
const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
#ifndef DEAL_II_MSVC
static_assert (std::is_same<typename VectorType::value_type,value_type>::value,
"The vector type must be based on the same value type as this"
"operator");
-#endif
#endif
Assert(mf_base_operator != NULL,
-#ifdef DEAL_II_WITH_CXX11
Subscriptor::Subscriptor (Subscriptor &&subscriptor)
:
counter(0),
{
subscriptor.check_no_subscribers();
}
-#endif
Subscriptor::~Subscriptor ()
{
check_no_subscribers();
-
-#ifdef DEAL_II_WITH_CXX11
object_info = nullptr;
-#else
- object_info = 0;
-#endif
}
-#ifdef DEAL_II_WITH_CXX11
Subscriptor &Subscriptor::operator = (Subscriptor &&s)
{
s.check_no_subscribers();
object_info = s.object_info;
return *this;
}
-#endif
+
void
projects / dealii.git / commitdiff