Commit a1d748cb authored by Praetorius, Simon's avatar Praetorius, Simon

rebase to develop branch

parent d5bd007f
Pipeline #1764 failed with stage
in 1 minute and 41 seconds
......@@ -5,6 +5,7 @@
#include <utility>
#include <amdis/common/Mpl.hpp>
#include <amdis/common/TypeTraits.hpp>
namespace AMDiS
{
......@@ -15,7 +16,7 @@ namespace AMDiS
template <class F, class Tuple, std::size_t... I>
constexpr decltype(auto) apply_impl(F&& f, Tuple&& t, std::index_sequence<I...>)
{
return f(std::get<I>(std::forward<Tuple>(t))...);
return f(std::get<I>(FWD(t))...);
}
template <class F, std::size_t I0, std::size_t... I>
......@@ -28,31 +29,27 @@ namespace AMDiS
template <class F, class Tuple>
constexpr decltype(auto) apply(F&& f, Tuple&& t)
{
return Impl_::apply_impl(
std::forward<F>(f), std::forward<Tuple>(t),
return Impl_::apply_impl(FWD(f), FWD(t),
std::make_index_sequence<std::tuple_size<std::remove_reference_t<Tuple>>::value>{});
}
template <class F, class... Args>
constexpr decltype(auto) apply_variadic(F&& f, Args&&... args)
{
return apply(std::forward<F>(f), std::forward_as_tuple(args...));
return apply(FWD(f), std::forward_as_tuple(args...));
}
template <class F, std::size_t N>
constexpr decltype(auto) apply_indices(F&& f, index_t<N>)
{
return Impl_::apply_indices_impl(
std::forward<F>(f),
index_t<0>{},
return Impl_::apply_indices_impl(FWD(f), index_t<0>{},
std::make_index_sequence<N>{});
}
template <class F, std::size_t I0, std::size_t I1>
constexpr decltype(auto) apply_indices(F&& f, index_t<I0>, index_t<I1>)
{
return Impl_::apply_indices_impl(
std::forward<F>(f), index_t<I0>{},
return Impl_::apply_indices_impl(FWD(f), index_t<I0>{},
std::make_index_sequence<I1-I0>{});
}
}
......
#pragma once
#include <memory>
#include <utility>
#include <amdis/common/Utility.hpp>
namespace AMDiS
{
// A pointer class that deletes only when owning the pointer
template <class T>
class ClonablePtr
{
private:
struct alloc_tag {}; ///< hidden helper struct, used by \ref make
public:
using Self = ClonablePtr;
using element_type = T;
/// Default constructor, creates a non-owned nullptr
ClonablePtr() = default;
/// Constructor from pointer. Can only be used via make method,
/// Transfers ownership.
ClonablePtr(owner<T>* p, alloc_tag) noexcept
: p(p)
, is_owner(true)
{}
/// Constructor from reference
explicit ClonablePtr(T& ref) noexcept
: p(&ref)
, is_owner(false)
{}
/// Constructor from std::unique_ptr
explicit ClonablePtr(std::unique_ptr<T>& ptr)
: p(ptr.release())
, is_owner(true)
{}
explicit ClonablePtr(std::unique_ptr<T>&& ptr)
: p(ptr.release())
, is_owner(true)
{}
/// Destructor, deletes in case of owner only
~ClonablePtr() noexcept
{
if (is_owner)
delete p;
}
/// Copy constructor, creates a clone of the pointed to object
ClonablePtr(Self const& that) noexcept( std::is_nothrow_copy_constructible<T>::value )
: p(new T(*that.p))
, is_owner(true)
{}
/// Move constructor, copies the pointer only.
ClonablePtr(Self&& that) noexcept
: p(that.p)
, is_owner(that.is_owner)
{
that.p = nullptr;
that.is_owner = false;
}
/// Copy and move assignment operator, using the copy-and-swap idiom
Self& operator=(Self that) noexcept
{
swap(that);
return *this;
}
/// Factory method. creates a new Object of type T and stores the pointer.
template <class... Args>
static Self make(Args&&... args)
noexcept( std::is_nothrow_constructible<T, remove_cvref_t<Args>...>::value )
{
return {new T(FWD(args)...), Self::alloc_tag()};
}
/// Access-method by dereferencing
T& operator*() const noexcept
{
return *p;
}
/// Access-method by pointer access
T* operator->() const noexcept
{
return p;
}
/// retrieve the underlying pointer
T* get() const noexcept
{
return p;
}
/// Test whether pointer is NULL
operator bool() const noexcept
{
return !(p == NULL);
}
void swap(Self& that) noexcept
{
using std::swap;
swap(p, that.p);
swap(is_owner, that.is_owner);
}
private:
T* p = nullptr; ///< managed pointer
bool is_owner = false; ///< true, if class is owner of pointer, false otherwise
};
template <class T>
void swap(ClonablePtr<T>& a, ClonablePtr<T>& b) noexcept
{
a.swap(b);
}
} // end namespace AMDiS
......@@ -20,7 +20,7 @@ namespace AMDiS
{
template <class A, class B>
struct IsSimilar
: std::is_same<std::decay_t<A>, std::decay_t<B>> {};
: std::is_same<remove_cvref_t<A>, remove_cvref_t<B>> {};
template <class A, class B>
struct IsSimilar<Types<A>, Types<B>>
......@@ -52,7 +52,7 @@ namespace AMDiS
struct Callable
{
template <class F, class... Args>
auto requires_(F&& f, Args&&... args) -> decltype( f(FWD(args)...));
auto requires_(F&& f, Args&&... args) -> decltype(f(FWD(args)...));
};
// idx[0]
......
......@@ -78,8 +78,7 @@ namespace AMDiS
template <class F, class... Args>
data_type const& get_or_init(key_type const& key, F&& f, Args&&... args) const
{
return impl(std::is_default_constructible<data_type>{},
key, std::forward<F>(f), std::forward<Args>(args)...);
return impl(std::is_default_constructible<data_type>{}, key, FWD(f), FWD(args)...);
}
private:
......@@ -90,7 +89,7 @@ namespace AMDiS
data_type empty;
auto it = cachedData_.emplace(key, std::move(empty));
if (it.second) {
data_type data = f(key, std::forward<Args>(args)...);
data_type data = f(key, FWD(args)...);
it.first->second = std::move(data);
}
return it.first->second;
......@@ -104,7 +103,7 @@ namespace AMDiS
if (it != cachedData_.end())
return it->second;
else {
data_type data = f(key, std::forward<Args>(args)...);
data_type data = f(key, FWD(args)...);
auto it = cachedData_.emplace(key, std::move(data));
return it.first->second;
}
......
......@@ -82,7 +82,7 @@ namespace Dune
template <class T>
decltype(auto) simplify(T&& t)
{
return std::forward<T>(t);
return FWD(t);
}
template <class T>
......
......@@ -305,7 +305,7 @@ T distance(FieldVector<T, N> const& lhs, FieldVector<T, N> const& rhs)
template <class T, class S, int N, int M, int K>
auto outer(FieldMatrix<T,N,K> const& vec1, FieldMatrix<S,M,K> const& vec2)
{
using result_type = FieldMatrix<decltype( std::declval<T>() * std::declval<S>() ), N, M>;
using result_type = FieldMatrix<TYPEOF( std::declval<T>() * std::declval<S>() ), N, M>;
result_type mat;
for (int i = 0; i < N; ++i)
for (int j = 0; j < M; ++j)
......
#pragma once
#include <dune/common/ftraits.hh>
#include <amdis/common/Utility.hpp>
namespace AMDiS
{
template <class... T>
struct CommonFieldTraits
{
using field_type = std::common_type_t<typename Dune::FieldTraits<T>::field_type...>;
using real_type = std::common_type_t<typename Dune::FieldTraits<T>::real_type...>;
};
} // end namespace AMDiS
#pragma once
// std c++ headers
#include <type_traits>
#include <amdis/common/Utility.hpp>
namespace AMDiS
{
namespace Traits
{
template <class T>
struct IsIntegral
: public std::is_integral<remove_cvref_t<T>> {};
template <class T>
struct IsArithmetic
: public std::is_arithmetic<remove_cvref_t<T>> {};
} // end namespace traits
namespace Concepts
{
/** \addtogroup Concepts
* @{
**/
/// \brief The types following the std type-trait \ref std::is_integral are
/// categorized as *integral types*.
template <class T>
constexpr bool Integral = Traits::IsIntegral<T>::value;
/// \brief The types following the std type-trait \ref std::is_arithmetic are
/// categorized as *arithmetic types*.
template <class T>
constexpr bool Arithmetic = Traits::IsArithmetic<T>::value;
/** @} **/
} // end namespace Concepts
} // end namespace AMDiS
......@@ -59,7 +59,7 @@ namespace AMDiS
template <class Obj>
auto makeUniquePtr(Obj&& obj)
{
return std::make_unique<std::decay_t<Obj>>(std::forward<Obj>(obj));
return std::make_unique<remove_cvref_t<Obj>>(FWD(obj));
}
} // end namespace AMDiS
#pragma once
#include <memory>
#include <type_traits>
#include <vector>
#if AMDIS_HAS_CXX_CONSTEXPR_IF
#define IF_CONSTEXPR if constexpr
#else
#define IF_CONSTEXPR if
#endif
namespace AMDiS
{
/// \brief Remove cv and ref qualifiers of type T.
/**
* If the type T is a reference type, provides the member typedef type which
* is the type referred to by T with its topmost cv-qualifiers removed.
* Otherwise type is T with its topmost cv-qualifiers removed.
*
* Note: This is a backport of c++20 std::remove_cvref
**/
template< class T >
struct remove_cvref
{
using type = std::remove_cv_t<std::remove_reference_t<T>>;
};
/// Helper alias template for \ref remove_cvref
template< class T >
using remove_cvref_t = typename remove_cvref<T>::type;
namespace Impl
{
template <class T>
struct UnderlyingType
{
using type = remove_cvref_t<T>;
};
template <class T>
struct UnderlyingType<std::reference_wrapper<T>>
{
using type = std::remove_cv_t<T>;
};
}
/// \brief strip reference_wrapper, const, volatile, and references from type T
template <class T>
using Underlying_t = typename Impl::UnderlyingType<T>::type;
/// Macro for forwarding universal references to obj
#define FWD(obj) std::forward<decltype(obj)>(obj)
/// A decay version of decltype, similar to GCCs __typeof__
#define TYPEOF(...) remove_cvref_t<decltype(__VA_ARGS__)>
/// Extract the static value of an integral_constant variable
#define VALUE(...) TYPEOF(__VA_ARGS__)::value
/// Create a unique_ptr by copy/move construction
template <class Obj>
auto makeUniquePtr(Obj&& obj)
{
return std::make_unique<TYPEOF(obj)>(FWD(obj));
}
// ---------------------------------------------------------------------------
// base template for tuple size, must implement a static value member
template <class TupleType>
struct TupleSize;
// utility constant returning the value of the tuple size
template <class TupleType>
constexpr std::size_t TupleSize_v = TupleSize<TupleType>::value;
// base template for retrieving the tuple element type, must implement the type member `type`
template <size_t I, class TupleType>
struct TupleElement;
// base template for retrieving the tuple element type
template <size_t I, class TupleType>
using TupleElement_t = typename TupleElement<I, TupleType>::type;
/// A variadic type list
template <class... Ts>
struct Types {};
template <class... Ts>
using Types_t = Types<remove_cvref_t<Ts>...>;
template <class... T>
struct TupleSize<Types<T...>>
: std::integral_constant<std::size_t, sizeof...(T)> {};
template <size_t I, class Head, class... Tail>
struct TupleElement<I, Types<Head, Tail...>>
{
using type = typename TupleElement<I-1, Types<Tail...>>::type;
};
template <class Head, class... Tail>
struct TupleElement<0, Types<Head, Tail...>>
{
using type = Head;
};
/// Alias that indicates ownership of resources
template <class T>
using owner = T;
// ---------------------------------------------------------------------------
/// generalization of get<tuple>, get<array> for vectors
template <std::size_t I, class T, class A>
T const& get(std::vector<T,A> const& vec)
{
return vec[I];
}
} // end namespace AMDiS
......@@ -11,6 +11,7 @@
#include <dune/typetree/treepath.hh>
#include <amdis/common/Apply.hpp>
#include <amdis/common/TypeTraits.hpp>
// NOTE: backport of dune/typetree/treecontainer.hh
......@@ -135,7 +136,7 @@ namespace AMDiS
template<class Container>
auto makeTreeContainerVectorBackend(Container&& container)
{
return TreeContainerVectorBackend<std::decay_t<Container>>(std::forward<Container>(container));
return TreeContainerVectorBackend<remove_cvref_t<Container>>(FWD(container));
}
} // end namespace Impl
......@@ -192,7 +193,7 @@ namespace AMDiS
* \brief Alias to container type generated by makeTreeContainer for given value and tree type
*/
template<class Value, class Tree>
using TreeContainer = std::decay_t<decltype(makeTreeContainer<Value>(std::declval<const Tree&>()))>;
using TreeContainer = TYPEOF(makeTreeContainer<Value>(std::declval<const Tree&>()));
//! \} group TypeTree
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment