Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
amdis
amdis-core
Commits
a1d748cb
Commit
a1d748cb
authored
Mar 01, 2019
by
Praetorius, Simon
Browse files
rebase to develop branch
parent
d5bd007f
Changes
11
Hide whitespace changes
Inline
Side-by-side
src/amdis/common/Apply.hpp
View file @
a1d748cb
...
...
@@ -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
>
{});
}
}
...
...
src/amdis/common/ClonablePtr.hpp
deleted
100644 → 0
View file @
d5bd007f
#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
src/amdis/common/Concepts.hpp
View file @
a1d748cb
...
...
@@ -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]
...
...
src/amdis/common/ConcurrentCache.hpp
View file @
a1d748cb
...
...
@@ -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
;
}
...
...
src/amdis/common/FieldMatVec.hpp
View file @
a1d748cb
...
...
@@ -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
>
...
...
src/amdis/common/FieldMatVec.inc.hpp
View file @
a1d748cb
...
...
@@ -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
)
...
...
src/amdis/common/FieldTraits.hpp
deleted
100644 → 0
View file @
d5bd007f
#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
src/amdis/common/ScalarTypes.hpp
deleted
100644 → 0
View file @
d5bd007f
#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
src/amdis/common/TypeTraits.hpp
View file @
a1d748cb
...
...
@@ -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
src/amdis/common/Utility.hpp
deleted
100644 → 0
View file @
d5bd007f
#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
src/amdis/typetree/TreeContainer.hpp
View file @
a1d748cb
...
...
@@ -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
...
...
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment