Program Listing for File macros.hpp
↰ Return to documentation for file (/tmp/ws/src/proxsuite/include/proxsuite/linalg/veg/internal/macros.hpp)
#ifndef VEG_MACROS_HPP_HSTLSKZXS
#define VEG_MACROS_HPP_HSTLSKZXS
#include "proxsuite/linalg/veg/internal/external/hedley.ext.hpp"
#include "proxsuite/linalg/veg/internal/typedefs.hpp"
#include "proxsuite/linalg/veg/internal/preprocessor.hpp"
#include "proxsuite/linalg/veg/internal/prologue.hpp"
#include <initializer_list>
#if _MSC_VER
#define PROXSUITE_PRETTY_FUNCTION __FUNCSIG__
#else
#define PROXSUITE_PRETTY_FUNCTION __PRETTY_FUNCTION__
#endif
#define PROXSUITE_THROW_PRETTY(condition, exception, message) \
if (condition) { \
std::ostringstream ss; \
ss << "From file: " << __FILE__ << "\n"; \
ss << "in function: " << PROXSUITE_PRETTY_FUNCTION << "\n"; \
ss << "at line: " << __LINE__ << "\n"; \
ss << message << "\n"; \
throw exception(ss.str()); \
}
#define PROXSUITE_CHECK_ARGUMENT_SIZE(size, expected_size, message) \
if (size != expected_size) { \
std::ostringstream oss; \
oss << "wrong argument size: expected " << expected_size << ", got " \
<< size << "\n"; \
oss << "hint: " << message << std::endl; \
PROXSUITE_THROW_PRETTY(true, std::invalid_argument, oss.str()); \
}
#if HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) || \
HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#define VEG_DEPRECATED(Reason) __declspec(deprecated(Reason))
#elif HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) || \
HEDLEY_GCC_VERSION_CHECK(4, 5, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \
HEDLEY_ARM_VERSION_CHECK(5, 6, 0) || \
HEDLEY_SUNPRO_VERSION_CHECK(5, 13, 0) || \
HEDLEY_PGI_VERSION_CHECK(17, 10, 0) || HEDLEY_TI_VERSION_CHECK(18, 1, 0) || \
HEDLEY_TI_ARMCL_VERSION_CHECK(18, 1, 0) || \
HEDLEY_TI_CL6X_VERSION_CHECK(8, 3, 0) || \
HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
HEDLEY_TI_CLPRU_VERSION_CHECK(2, 3, 0)
#define VEG_DEPRECATED(Reason) __attribute__((__deprecated__(Reason)))
#elif defined(VEG_WITH_CXX14_SUPPORT)
#define VEG_DEPRECATED(Reason) \
HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated(Reason)]])
#elif HEDLEY_HAS_ATTRIBUTE(deprecated) || HEDLEY_GCC_VERSION_CHECK(3, 1, 0) || \
HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \
(HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && \
defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \
(HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && \
defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \
(HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && \
defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \
(HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && \
defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || \
HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)
#define VEG_DEPRECATED(Reason) __attribute__((__deprecated__))
#elif HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) || \
HEDLEY_PELLES_VERSION_CHECK(6, 50, 0) || \
HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#define VEG_DEPRECATED(Reason) __declspec(deprecated)
#elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
#define VEG_DEPRECATED(Reason) _Pragma("deprecated")
#else
#define VEG_DEPRECATED(Reason)
#endif
#define VEG_UNUSED_VARIABLE(var) (void)(var)
#ifdef NDEBUG
#define VEG_ONLY_USED_FOR_DEBUG(var) VEG_UNUSED_VARIABLE(var)
#else
#define VEG_ONLY_USED_FOR_DEBUG(var)
#endif
#if defined(__clang__)
#define VEG_WRAP_SILENCE_WARNING(...) \
HEDLEY_DIAGNOSTIC_PUSH _Pragma( \
"clang diagnostic ignored \"-Wc++17-extensions\"") \
__VA_ARGS__ HEDLEY_DIAGNOSTIC_POP
#else
#define VEG_WRAP_SILENCE_WARNING(...) __VA_ARGS__
#endif
#ifndef VEG_HAS_NO_UNIQUE_ADDRESS
#define VEG_HAS_NO_UNIQUE_ADDRESS 0
#endif
#if VEG_HAS_NO_UNIQUE_ADDRESS
#ifdef _MSC_VER
#define VEG_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
#else
#define VEG_NO_UNIQUE_ADDRESS [[no_unique_address]]
#endif
#else
#define VEG_NO_UNIQUE_ADDRESS
#endif
#ifndef VEG_INLINE
#if defined(NDEBUG) || defined(__OPTIMIZE__)
#define VEG_INLINE HEDLEY_ALWAYS_INLINE
#else
#define VEG_INLINE inline
#endif
#endif
#define VEG_NO_INLINE HEDLEY_NEVER_INLINE
#if defined(__cpp_concepts) && __cpp_concepts >= 201907L
#define VEG_HAS_CONCEPTS 1
#else
#define VEG_HAS_CONCEPTS 0
#endif
#if defined(VEG_WITH_CXX17_SUPPORT)
#define VEG_DECLVAL(...) (static_cast<__VA_ARGS__ (*)() noexcept>(nullptr)())
#else
#define VEG_DECLVAL(...) \
(::proxsuite::linalg::veg::_detail::_meta::declval<__VA_ARGS__>())
#endif
#if defined(__clang__)
#define VEG_ARROW(...) \
__attribute__((always_inline)) noexcept(noexcept((__VA_ARGS__))) \
->decltype((__VA_ARGS__)) \
{ \
return __VA_ARGS__; \
}
#elif defined(__GNUC__) && (__GNUC__ >= 9)
#define VEG_ARROW(...) \
noexcept(noexcept((__VA_ARGS__))) __attribute__((always_inline)) \
->decltype((__VA_ARGS__)) \
{ \
return __VA_ARGS__; \
}
#else
#define VEG_ARROW(...) \
noexcept(noexcept((__VA_ARGS__)))->decltype((__VA_ARGS__)) \
{ \
return __VA_ARGS__; \
}
#endif
#define VEG_LAZY_BY_REF(...) [&]() VEG_ARROW(__VA_ARGS__)
#define VEG_LIFT(...) \
[&](auto&&... args) VEG_ARROW((__VA_ARGS__)(VEG_FWD(args)...))
#define VEG_DEDUCE_RET(...) \
noexcept(noexcept(__VA_ARGS__))->decltype(__VA_ARGS__) \
{ \
return __VA_ARGS__; \
} \
VEG_NOM_SEMICOLON
#if defined(VEG_WITH_CXX17_SUPPORT)
#define VEG_HAS_FOLD_EXPR 1
#define VEG_ALL_OF(...) (__VA_ARGS__ && ... && true)
#define VEG_ANY_OF(...) (__VA_ARGS__ || ... || false)
#elif defined(__clang__)
#define VEG_HAS_FOLD_EXPR 1
#define VEG_ALL_OF(...) VEG_WRAP_SILENCE_WARNING((__VA_ARGS__ && ... && true))
#define VEG_ANY_OF(...) VEG_WRAP_SILENCE_WARNING((__VA_ARGS__ || ... || false))
#else
#define VEG_HAS_FOLD_EXPR 0
#define VEG_ALL_OF(...) \
::proxsuite::linalg::veg::meta::and_test< \
::proxsuite::linalg::veg::meta::make_index_sequence< \
::proxsuite::linalg::veg::meta::pack_size<decltype(( \
void)(__VA_ARGS__))...>::value>, \
::proxsuite::linalg::veg::meta::bool_constant<(__VA_ARGS__)>...>::value
#define VEG_ANY_OF(...) \
::proxsuite::linalg::veg::meta::or_test< \
::proxsuite::linalg::veg::meta::make_index_sequence< \
::proxsuite::linalg::veg::meta::pack_size<decltype(( \
void)(__VA_ARGS__))...>::value>, \
::proxsuite::linalg::veg::meta::bool_constant<(__VA_ARGS__)>...>::value
#endif
#define VEG_EVAL_ALL(...) \
((void)(::proxsuite::linalg::veg::_detail::EmptyArr{ \
::proxsuite::linalg::veg::_detail::Empty{}, \
((void)(__VA_ARGS__), ::proxsuite::linalg::veg::_detail::Empty{})... }))
#if VEG_HAS_CONCEPTS
#define __VEG_IMPL_AND(_, Param) &&__VEG_PP_UNWRAP(Param)
#define __VEG_IMPL_OR(_, Param) || __VEG_PP_UNWRAP(Param)
#define __VEG_IMPL_CONJUNCTION(First, ...) \
(__VEG_PP_UNWRAP(First) \
__VEG_PP_TUPLE_FOR_EACH(__VEG_IMPL_AND, _, (__VA_ARGS__)))
#define __VEG_IMPL_DISJUNCTION(First, ...) \
(__VEG_PP_UNWRAP(First) \
__VEG_PP_TUPLE_FOR_EACH(__VEG_IMPL_OR, _, (__VA_ARGS__)))
#define VEG_DEF_CONCEPT(Tpl, Name, ...) \
template<__VEG_PP_REMOVE_PAREN1(Tpl)> \
concept Name = __VA_ARGS__; \
VEG_NOM_SEMICOLON
#define VEG_CHECK_CONCEPT_MACRO(Namespace, ...) \
static_assert(Namespace::__VA_ARGS__, \
__VEG_PP_STRINGIZE(__VA_ARGS__) " failed")
#define VEG_CONCEPT_MACRO(Namespace, ...) Namespace::__VA_ARGS__
#define VEG_DEF_CONCEPT_CONJUNCTION(Tpl, Name, Terms) \
VEG_DEF_CONCEPT(Tpl, Name, __VEG_IMPL_CONJUNCTION Terms)
#define VEG_DEF_CONCEPT_DISJUNCTION(Tpl, Name, Terms) \
VEG_DEF_CONCEPT(Tpl, Name, __VEG_IMPL_DISJUNCTION Terms)
#define VEG_CONCEPT_EXPR(Tpl, TplNames, Name, Expr, ...) \
namespace _veg_detail { \
template<typename ExprType, __VEG_PP_REMOVE_PAREN1(Tpl)> \
concept test_return_##Name = __VA_ARGS__; \
} \
template<__VEG_PP_REMOVE_PAREN1(Tpl)> \
concept Name = \
_veg_detail::test_return_##Name<decltype((Expr)), \
__VEG_PP_REMOVE_PAREN1(TplNames)>; \
template<__VEG_PP_REMOVE_PAREN1(Tpl)> \
concept xnothrow_##Name = noexcept(Expr); \
template<__VEG_PP_REMOVE_PAREN1(Tpl)> \
concept nothrow_##Name = noexcept(Expr); \
VEG_NOM_SEMICOLON
#else
#if defined(VEG_WITH_CXX14_SUPPORT)
#define __VEG_IMPL_DEF_CONCEPT(Tpl, Name, Value, ...) \
namespace _ { \
template<__VEG_PP_REMOVE_PAREN1(Tpl)> \
struct Name : __VA_ARGS__ \
{}; \
} \
namespace { \
template<__VEG_PP_REMOVE_PAREN1(Tpl)> \
constexpr bool const& Name = \
::proxsuite::linalg::veg::meta::bool_constant<Value>::value; \
} \
VEG_NOM_SEMICOLON
#else
#define __VEG_IMPL_DEF_CONCEPT(Tpl, Name, Value, ...) \
template<__VEG_PP_REMOVE_PAREN1(Tpl)> \
struct Name : __VA_ARGS__ \
{}
#endif
#ifdef __clang__
#define __VEG_NO_WARNING_PRAGMA_PUSH \
HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic ignored \"-Wconversion\"")
#define __VEG_NO_WARNING_PRAGMA_POP HEDLEY_DIAGNOSTIC_POP
#else
#define __VEG_NO_WARNING_PRAGMA_PUSH
#define __VEG_NO_WARNING_PRAGMA_POP
#endif
#define VEG_CONCEPT_EXPR(Tpl, TplNames, Name, Expr, ...) \
namespace _veg_detail { \
template<typename _veg_Enable, __VEG_PP_REMOVE_PAREN1(Tpl)> \
struct test_sfinae_##Name \
{ \
using TestExpr = ::proxsuite::linalg::veg::meta::false_type; \
using NothrowTestExpr = ::proxsuite::linalg::veg::meta::false_type; \
}; \
template<__VEG_PP_REMOVE_PAREN1(Tpl)> \
struct test_sfinae_##Name< \
::proxsuite::linalg::veg::meta::void_t<decltype((Expr))>, \
__VEG_PP_REMOVE_PAREN1(TplNames)> \
{ \
using ExprType = decltype((Expr)); \
using TestExpr = \
::proxsuite::linalg::veg::meta::bool_constant<__VA_ARGS__>; \
using NothrowTestExpr = ::proxsuite::linalg::veg::meta::bool_constant< \
(TestExpr::value) && __VEG_NO_WARNING_PRAGMA_PUSH noexcept(Expr) \
__VEG_NO_WARNING_PRAGMA_POP>; \
}; \
} \
VEG_DEF_CONCEPT( \
Tpl, \
Name, \
_veg_detail::test_sfinae_##Name<void, __VEG_PP_REMOVE_PAREN1(TplNames)>:: \
TestExpr::value); \
VEG_DEF_CONCEPT(Tpl, nothrow_##Name, noexcept(Expr)); \
VEG_DEF_CONCEPT( \
Tpl, \
xnothrow_##Name, \
_veg_detail::test_sfinae_##Name<void, __VEG_PP_REMOVE_PAREN1(TplNames)>:: \
NothrowTestExpr::value); \
VEG_NOM_SEMICOLON
#if defined(VEG_WITH_CXX14_SUPPORT)
#define VEG_CONCEPT_MACRO(Namespace, ...) Namespace::__VA_ARGS__
#define __VEG_IMPL_ADD_VALUE(I, _, Param) (Param)
#define __VEG_IMPL_TRAIT(Param) __VEG_PP_HEAD Param _::__VEG_PP_TAIL Param
#else
#define VEG_CONCEPT_MACRO(Namespace, ...) Namespace::__VA_ARGS__::value
#define __VEG_IMPL_ADD_VALUE(I, _, Param) \
((__VEG_PP_REMOVE_PAREN(Param)::value))
#define __VEG_IMPL_TRAIT(Param) __VEG_PP_UNWRAP(Param)
#endif
#define __VEG_IMPL_PUT_TRAIT(I, _, Param) __VEG_IMPL_TRAIT(Param)
#define VEG_CHECK_CONCEPT_MACRO(Namespace, ...) \
static_assert(decltype(Namespace::check_##__VA_ARGS__())::value, \
__VEG_PP_STRINGIZE(__VA_ARGS__) " failed")
#define VEG_DEF_CONCEPT(Tpl, Name, ...) \
__VEG_IMPL_DEF_CONCEPT( \
Tpl, \
Name, \
(__VA_ARGS__), \
::proxsuite::linalg::veg::meta::bool_constant<__VA_ARGS__>); \
VEG_TEMPLATE(Tpl, \
requires(__VA_ARGS__), \
constexpr auto check_##Name, \
(_ = 0, int)) noexcept \
-> ::proxsuite::linalg::veg::meta::true_type
#define __VEG_IMPL_SFINAE(_, Param) \
, ::proxsuite::linalg::veg::meta:: \
enable_if_t<__VEG_PP_ID(__VEG_PP_UNWRAP Param), int> = 0
#define __VEG_IMPL_OVERLOAD(Name_Tpl, Param) \
template<__VEG_PP_REMOVE_PAREN(__VEG_PP_TAIL Name_Tpl), \
typename ::proxsuite::linalg::veg::_detail::_meta:: \
enable_if<__VEG_PP_ID(__VEG_PP_UNWRAP Param), int>::type = 0> \
auto __VEG_PP_CAT(check_, __VEG_PP_HEAD Name_Tpl)() noexcept \
-> ::proxsuite::linalg::veg::meta::true_type;
#define VEG_DEF_CONCEPT_BOOL_CONJUNCTION_IMPL(Tpl, Name, Base, Seq) \
__VEG_IMPL_DEF_CONCEPT(Tpl, \
Name, \
(__VEG_PP_REMOVE_PAREN1(Base)::value), \
__VEG_PP_REMOVE_PAREN1(Base)); \
template<__VEG_PP_REMOVE_PAREN(Tpl) \
__VEG_PP_TUPLE_FOR_EACH(__VEG_IMPL_SFINAE, _, Seq)> \
auto check_##Name() noexcept -> ::proxsuite::linalg::veg::meta::true_type
#define VEG_DEF_CONCEPT_BOOL_DISJUNCTION_IMPL(Tpl, Name, Base, Seq) \
__VEG_IMPL_DEF_CONCEPT(Tpl, \
Name, \
(__VEG_PP_REMOVE_PAREN1(Base)::value), \
__VEG_PP_REMOVE_PAREN1(Base)); \
__VEG_PP_TUPLE_FOR_EACH(__VEG_IMPL_OVERLOAD, (Name, Tpl), Seq) \
VEG_NOM_SEMICOLON
#define VEG_DEF_CONCEPT_CONJUNCTION(Tpl, Name, Terms) \
VEG_DEF_CONCEPT_BOOL_CONJUNCTION_IMPL( \
Tpl, \
Name, \
(__VEG_IMPL_CONJUNCTION(Terms)), \
__VEG_PP_TUPLE_TRANSFORM_I(__VEG_IMPL_ADD_VALUE, _, Terms))
#define VEG_DEF_CONCEPT_DISJUNCTION(Tpl, Name, Terms) \
VEG_DEF_CONCEPT_BOOL_DISJUNCTION_IMPL( \
Tpl, \
Name, \
(__VEG_IMPL_DISJUNCTION(Terms)), \
__VEG_PP_TUPLE_TRANSFORM_I(__VEG_IMPL_ADD_VALUE, _, Terms))
#define __VEG_IMPL_CONJUNCTION(Tuple) \
::proxsuite::linalg::veg::meta::conjunction<__VEG_PP_REMOVE_PAREN( \
__VEG_PP_TUPLE_TRANSFORM_I(__VEG_IMPL_PUT_TRAIT, _, Tuple))>
#define __VEG_IMPL_DISJUNCTION(Tuple) \
::proxsuite::linalg::veg::meta::disjunction<__VEG_PP_REMOVE_PAREN( \
__VEG_PP_TUPLE_TRANSFORM_I(__VEG_IMPL_PUT_TRAIT, _, Tuple))>
#endif
#define VEG_TEMPLATE(TParams, Constraint, Attr_Name, ...) \
__VEG_IMPL_TEMPLATE(Attr_Name, \
TParams, \
__VEG_PP_CAT2(__VEG_IMPL_PREFIX_, Constraint), \
__VA_ARGS__)
#if VEG_HAS_CONCEPTS
#define VEG_CONSTRAINED_MEMBER_FN(Constraint, Attr_Name, Params, ...) \
Attr_Name __VEG_PP_TUPLE_TRANSFORM_I(__VEG_IMPL_PARAM_EXPAND, _, Params) \
__VA_ARGS__ \
requires __VEG_PP_CAT2(__VEG_IMPL_PREFIX_, Constraint)
#define VEG_TEMPLATE_CVT(TParams, Constraint, Attr, ...) \
template<__VEG_PP_REMOVE_PAREN(TParams)> \
Constraint Attr operator __VA_ARGS__()
#else
#define VEG_CONSTRAINED_MEMBER_FN(Constraint, Attr_Name, Params, ...) \
VEG_TEMPLATE( \
(int _ = 0), \
requires(__VEG_PP_CAT2(__VEG_IMPL_PREFIX_, Constraint) && \
::proxsuite::linalg::veg::meta::bool_constant<(_ == 0)>::value), \
Attr_Name, \
__VEG_PP_REMOVE_PAREN(Params)) \
__VA_ARGS__
#define VEG_TEMPLATE_CVT(TParams, Constraint, Attr, ...) \
template<__VEG_PP_REMOVE_PAREN(TParams)> \
Attr operator ::proxsuite::linalg::veg::meta::enable_if_t< \
(__VEG_PP_CAT2(__VEG_IMPL_PREFIX_, Constraint)), \
__VA_ARGS__>()
#endif
#if VEG_HAS_CONCEPTS && defined(__cpp_conditional_explicit) && \
(__cpp_conditional_explicit >= 201806L)
#define VEG_TEMPLATE_EXPLICIT( \
TParams, Constraint, Explicit_Cond, Attr_Name, Params, ...) \
VEG_TEMPLATE(TParams, \
Constraint, \
Explicit_Cond Attr_Name, \
__VEG_PP_REMOVE_PAREN(Params)) \
__VA_ARGS__
#define VEG_TEMPLATE_CVT_EXPLICIT( \
TParams, Constraint, Explicit_Cond, Attr, Type, ...) \
template<__VEG_PP_REMOVE_PAREN(TParams)> \
Constraint Explicit_Cond Attr operator __VEG_PP_REMOVE_PAREN(Type)() \
__VA_ARGS__
#else
#define VEG_TEMPLATE_EXPLICIT( \
TParams, Constraint, Explicit_Cond, Attr_Name, Params, ...) \
VEG_TEMPLATE( \
(__VEG_PP_REMOVE_PAREN TParams, \
::proxsuite::linalg::veg::meta:: \
enable_if_t<(__VEG_PP_CAT2(__VEG_IMPL_PREFIX_, Explicit_Cond)), int> = \
0), \
Constraint, \
explicit Attr_Name, \
__VEG_PP_REMOVE_PAREN(Params)) \
__VA_ARGS__ \
VEG_TEMPLATE((__VEG_PP_REMOVE_PAREN TParams, \
::proxsuite::linalg::veg::meta::enable_if_t< \
!(__VEG_PP_CAT2(__VEG_IMPL_PREFIX_, Explicit_Cond)), \
unsigned> = 0), \
Constraint, \
Attr_Name, \
__VEG_PP_REMOVE_PAREN(Params)) \
__VA_ARGS__
#define VEG_TEMPLATE_CVT_EXPLICIT( \
TParams, Constraint, Explicit_Cond, Attr, Type, ...) \
VEG_TEMPLATE_CVT( \
(__VEG_PP_REMOVE_PAREN TParams, \
::proxsuite::linalg::veg::meta:: \
enable_if_t<(__VEG_PP_CAT2(__VEG_IMPL_PREFIX_, Explicit_Cond)), int> = \
0), \
Constraint, \
explicit Attr, \
__VEG_PP_REMOVE_PAREN(Type)) \
__VA_ARGS__ \
\
VEG_TEMPLATE_CVT((__VEG_PP_REMOVE_PAREN TParams, \
::proxsuite::linalg::veg::meta::enable_if_t< \
!(__VEG_PP_CAT2(__VEG_IMPL_PREFIX_, Explicit_Cond)), \
unsigned> = 0), \
Constraint, \
Attr, \
__VEG_PP_REMOVE_PAREN(Type)) \
__VA_ARGS__
#endif
#define __VEG_IMPL_PREFIX_requires
#define __VEG_IMPL_PREFIX_explicit
#define __VEG_IMPL_PARAM_EXPAND(I, _, Param) \
__VEG_PP_TAIL Param __VEG_PP_HEAD Param
#if VEG_HAS_CONCEPTS
#define __VEG_IMPL_TEMPLATE(Attr_Name, TParams, Constraint, ...) \
template<__VEG_PP_REMOVE_PAREN(TParams)> \
requires Constraint \
Attr_Name __VEG_PP_TUPLE_TRANSFORM_I( \
__VEG_IMPL_PARAM_EXPAND, _, (__VA_ARGS__))
#else
#define __VEG_IMPL_TEMPLATE2_HELPER_0(Constraint, Param) \
__VEG_PP_TAIL Param __VEG_PP_HEAD Param
#define __VEG_IMPL_TEMPLATE2_HELPER_1(Constraint, Param) \
::proxsuite::linalg::veg::meta::enable_if_t<(Constraint), \
__VEG_PP_TAIL Param> \
__VEG_PP_HEAD Param
#define __VEG_IMPL_TEMPLATE2_HELPER(I, Constraint, Param) \
__VEG_PP_CAT2(__VEG_IMPL_TEMPLATE2_HELPER_, \
__VEG_IMPL_PP_IS_1(__VEG_IMPL_PP_INC(I))) \
(Constraint, Param)
#define __VEG_IMPL_TEMPLATE(Attr_Name, TParams, Constraint, ...) \
template<__VEG_PP_REMOVE_PAREN(TParams)> \
Attr_Name __VEG_PP_TUPLE_TRANSFORM_I( \
__VEG_IMPL_TEMPLATE2_HELPER, Constraint, (__VA_ARGS__))
#endif
#if defined(VEG_WITH_CXX17_SUPPORT)
#define VEG_INLINE_VAR(Name, Obj) \
inline constexpr auto const& Name = \
::proxsuite::linalg::veg::meta::static_const<Obj>::value; \
static_assert((void(Name), true), ".")
#define VEG_INLINE_VAR_TEMPLATE(Tpl, Name, ...) /* NOLINT */ \
template<__VEG_PP_REMOVE_PAREN(Tpl)> \
inline constexpr auto const& Name = \
::proxsuite::linalg::veg::meta::static_const<__VA_ARGS__>::value; \
VEG_NOM_SEMICOLON /* NOLINT */
#else
#define VEG_INLINE_VAR(Name, Obj) \
namespace /* NOLINT */ { \
constexpr auto const& Name = \
::proxsuite::linalg::veg::meta::static_const<Obj>::value; \
} \
static_assert((void(Name), true), ".")
#if defined(VEG_WITH_CXX14_SUPPORT)
#define VEG_INLINE_VAR_TEMPLATE(Tpl, Name, ...) /* NOLINT */ \
namespace /* NOLINT */ { /* NOLINT */ \
template<__VEG_PP_REMOVE_PAREN(Tpl)> \
constexpr auto const& Name = /* NOLINT */ \
::proxsuite::linalg::veg::meta::static_const< \
__VA_ARGS__>::value; /* NOLINT \
*/ \
} \
VEG_NOM_SEMICOLON /* NOLINT */
#else
#define VEG_INLINE_VAR_TEMPLATE(Tpl, Name, ...) VEG_NOM_SEMICOLON
#endif
#endif
#define VEG_NIEBLOID(Name) VEG_INLINE_VAR(Name, nb::Name) // NOLINT
#define VEG_NIEBLOID_TEMPLATE(Tpl, Name, ...) \
VEG_INLINE_VAR_TEMPLATE(Tpl, Name, nb::Name<__VA_ARGS__>) // NOLINT
#define VEG_TAG(Name, Type) \
namespace _ { \
template<int I> \
struct Type \
{ \
explicit Type() = default; \
}; \
} \
using Type = _::Type<0>; \
VEG_INLINE_VAR(Name, Type)
#define VEG_TAG_TEMPLATE(Tpl, Name, Type, ...) \
template<__VEG_PP_REMOVE_PAREN(Tpl)> \
struct Type \
{ \
explicit Type() = default; \
}; \
VEG_INLINE_VAR_TEMPLATE(Tpl, Name, Type<__VA_ARGS__>)
#define VEG_FWD(X) static_cast<decltype(X)&&>(X)
#define VEG_FWD2(X) static_cast<decltype(X)>(static_cast<decltype(X)&&>(X))
// disallows moving const rvalues
#define VEG_MOV(X) \
static_cast<typename ::proxsuite::linalg::veg::uncvref_t<decltype(X)>&&>(X)
#ifdef VEG_NO_INSTANTIATE
#define VEG_INSTANTIATE(Fn, ...) VEG_NOM_SEMICOLON
#define VEG_INSTANTIATE_CLASS(Class, ...) VEG_NOM_SEMICOLON
#else
#define VEG_INSTANTIATE(Fn, ...) \
__VEG_IMPL_INSTANTIATE( \
Fn, \
__VEG_PP_CAT(__VEG_PP_CAT(_dummy_explicit_instantiation, __LINE__), \
__VEG_PP_CAT(_, __COUNTER__)), \
__VA_ARGS__)
#define __VEG_IMPL_INSTANTIATE(Fn, Name, ...) \
template<typename... Ts> \
struct Name \
{ \
void apply(Ts&&... args) \
{ \
Fn(VEG_FWD(args)...); \
} \
}; \
template struct Name<__VA_ARGS__>
#define VEG_INSTANTIATE_CLASS(Class, ...) template struct Class<__VA_ARGS__>
#endif
#define VEG_NOM_SEMICOLON static_assert(true, ".")
#define VEG_ID(id) __VEG_PP_CAT(id, __COUNTER__)
namespace proxsuite {
namespace linalg {
namespace veg {
template<typename T>
struct Slice;
namespace meta {
template<typename...>
using void_t = void;
} // namespace meta
namespace _detail {
template<typename T>
struct Wrapper
{
T inner;
};
namespace _meta {
template<bool B, typename T = void>
struct enable_if
{
using type = T;
};
template<typename T>
struct enable_if<false, T>
{};
template<typename U, typename V>
using discard_1st = V;
template<typename T>
struct uncvlref;
template<typename T>
struct uncvlref<T&>
{
using type = T;
};
template<typename T>
struct uncvlref<T const&>
{
using type = T;
};
template<typename T>
struct uncvlref<T volatile&>
{
using type = T;
};
template<typename T>
struct uncvlref<T volatile const&>
{
using type = T;
};
template<typename T>
struct unref;
template<typename T>
struct unref<T&>
{
using type = T;
};
template<typename T>
auto
declval() VEG_ALWAYS_NOEXCEPT->T;
} // namespace _meta
} // namespace _detail
namespace meta {
template<typename T>
struct static_const
{
static constexpr T value{};
};
template<typename T>
constexpr T static_const<T>::value; // NOLINT(readability-redundant-declaration)
} // namespace meta
template<typename... Ts>
struct incomplete_t;
template<typename... Types, typename... Args>
auto
print_types_halt(Args&&...) -> incomplete_t<Types..., Args...>;
template<typename... Types, typename... Args>
VEG_DEPRECATED("")
VEG_CPP14(constexpr) void print_types(Args&&... /*unused*/)
{
}
namespace nb {
struct unused
{
template<typename... Ts>
VEG_CPP14(constexpr)
void operator()(Ts const&... /*unused*/) const VEG_NOEXCEPT
{
}
};
} // namespace nb
VEG_NIEBLOID(unused);
using usize = decltype(sizeof(0));
namespace _detail {
template<isize I>
struct EmptyI
{};
using Empty = EmptyI<0>;
using EmptyArr = Empty[];
namespace _meta {
template<typename T, T... Nums>
struct integer_sequence;
#if VEG_HAS_BUILTIN(__make_integer_seq)
template<typename T, T N>
using make_integer_sequence = __make_integer_seq<integer_sequence, T, N>;
#elif __GNUC__ >= 8
template<typename T, T N>
using make_integer_sequence = integer_sequence<T, __integer_pack(N)...>;
#else
namespace _detail {
template<typename Seq1, typename Seq2>
struct _merge;
template<typename Seq1, typename Seq2>
struct _merge_p1;
template<typename T, T... Nums1, T... Nums2>
struct _merge<integer_sequence<T, Nums1...>, integer_sequence<T, Nums2...>>
{
using type = integer_sequence<T, Nums1..., (sizeof...(Nums1) + Nums2)...>;
};
template<typename T, T... Nums1, T... Nums2>
struct _merge_p1<integer_sequence<T, Nums1...>, integer_sequence<T, Nums2...>>
{
using type = integer_sequence<T,
Nums1...,
(sizeof...(Nums1) + Nums2)...,
sizeof...(Nums1) + sizeof...(Nums2)>;
};
template<typename T, usize N, bool Even = (N % 2) == 0>
struct _make_integer_sequence
{
using type =
typename _merge<typename _make_integer_sequence<T, N / 2>::type,
typename _make_integer_sequence<T, N / 2>::type>::type;
};
template<typename T, usize N>
struct _make_integer_sequence<T, N, false>
{
using type =
typename _merge_p1<typename _make_integer_sequence<T, N / 2>::type,
typename _make_integer_sequence<T, N / 2>::type>::type;
};
template<typename T>
struct _make_integer_sequence<T, 0>
{
using type = integer_sequence<T>;
};
template<typename T>
struct _make_integer_sequence<T, 1>
{
using type = integer_sequence<T, 0>;
};
} // namespace _detail
template<typename T, T N>
using make_integer_sequence =
typename _detail::_make_integer_sequence<T, N>::type;
#endif
#define VEG_DEF_CONCEPT_BUILTIN_OR_INTERNAL(Tpl, Name, ...) \
VEG_DEF_CONCEPT( \
Tpl, \
Name, \
VEG_HAS_BUILTIN_OR(__is_##Name, \
__is_##Name(__VA_ARGS__), \
(_detail::_meta::is_##Name<__VA_ARGS__>::value)))
template<usize N>
using make_index_sequence = make_integer_sequence<usize, N>;
template<typename... Ts>
struct type_sequence;
} // namespace _meta
template<usize I, typename T>
struct SimpleLeaf
{
T inner;
};
template<typename Seq, typename... Ts>
struct SimpleITuple;
template<usize... Is, typename... Ts>
struct SimpleITuple<_meta::integer_sequence<usize, Is...>, Ts...>
: SimpleLeaf<Is, Ts>...
{
#if !defined(VEG_WITH_CXX17_SUPPORT)
constexpr SimpleITuple(Ts... args) noexcept
: SimpleLeaf<Is, Ts>{ Ts(VEG_FWD(args)) }...
{
}
#endif
};
template<typename... Ts>
using SimpleTuple =
SimpleITuple<_meta::make_index_sequence<sizeof...(Ts)>, Ts...>;
template<typename... Ts>
constexpr auto
make_simple_tuple(Empty /*dummy*/, Ts... args) noexcept -> SimpleTuple<Ts...>
{
#if !defined(VEG_WITH_CXX17_SUPPORT)
return { Ts(VEG_FWD(args))... };
#else
return { { Ts(VEG_FWD(args)) }... };
#endif
}
template<typename T>
struct mem_ptr_type;
template<typename C, typename Mem>
struct mem_ptr_type<Mem C::*>
{
using Type = Mem;
};
constexpr auto
all_of_slice(bool const* arr, usize size) VEG_NOEXCEPT->bool
{
return size == 0 ? true
: (arr[0] && _detail::all_of_slice(arr + 1, size - 1));
}
template<usize N>
inline constexpr auto
all_of(bool const (&lst)[N]) VEG_NOEXCEPT->bool
{
return _detail::all_of_slice(lst, N);
}
template<typename T>
struct member_extract_access
{
template<typename U, typename = U>
struct DetectImpl
{
static constexpr bool value = false;
using Type = void;
};
template<typename U>
struct DetectImpl<U, typename U::_veglib_impl_member_extract::Type>
{
static constexpr bool value = true;
using Type = typename U::_veglib_impl_member_extract;
};
using Detect = DetectImpl<T>;
static constexpr bool value = Detect::value;
using Type = typename Detect::Type;
};
} // namespace _detail
namespace meta {
template<bool B, typename T = void>
using enable_if_t =
_detail::_meta::discard_1st<typename _detail::_meta::enable_if<B, void>::type,
T>;
template<typename T>
using uncvref_t = typename _detail::_meta::uncvlref<T&>::type;
} // namespace meta
using meta::uncvref_t;
namespace meta {
template<typename T, T Value>
struct constant
{
static constexpr T value = Value;
};
template<typename T, T Value>
constexpr T constant<T, Value>::value;
template<bool B>
using bool_constant = constant<bool, B>;
using true_type = bool_constant<true>;
using false_type = bool_constant<false>;
} // namespace meta
namespace _detail {
namespace _meta {
struct wrapper_base
{
static auto test(...) -> meta::false_type;
};
template<typename T>
struct wrapper : wrapper_base
{
using wrapper_base::test;
static auto test(wrapper<T>*) -> meta::true_type;
};
template<typename T, typename U>
using is_same = decltype(wrapper<T>::test(static_cast<wrapper<U>*>(nullptr)));
} // namespace _meta
} // namespace _detail
namespace concepts {
VEG_DEF_CONCEPT_BUILTIN_OR_INTERNAL((typename T, typename U), same, T, U);
} // namespace concepts
enum struct CharUnit : unsigned char
{
SPACE = 0x20,
EXCLAMATION_MARK = 0x21,
DOUBLE_QUOTE = 0x22,
NUMBER = 0x23,
DOLLAR = 0x24,
PERCENT = 0x25,
AMPERSAND = 0x26,
SINGLE_QUOTE = 0x27,
LEFT_PARENTHESIS = 0x28,
RIGHT_PARENTHESIS = 0x29,
ASTERISK = 0x2A,
PLUS = 0x2B,
COMMA = 0x2C,
MINUS = 0x2D,
PERIOD = 0x2E,
SLASH = 0x2F,
ZERO = 0x30,
ONE = 0x31,
TWO = 0x32,
THREE = 0x33,
FOUR = 0x34,
FIVE = 0x35,
SIX = 0x36,
SEVEN = 0x37,
EIGHT = 0x38,
NINE = 0x39,
COLON = 0x3A,
SEMICOLON = 0x3B,
LESS_THAN = 0x3C,
EQUALITY_SIGN = 0x3D,
GREATER_THAN = 0x3E,
QUESTION_MARK = 0x3F,
AT_SIGN = 0x40,
UPPERCASE_A = 0x41,
UPPERCASE_B = 0x42,
UPPERCASE_C = 0x43,
UPPERCASE_D = 0x44,
UPPERCASE_E = 0x45,
UPPERCASE_F = 0x46,
UPPERCASE_G = 0x47,
UPPERCASE_H = 0x48,
UPPERCASE_I = 0x49,
UPPERCASE_J = 0x4A,
UPPERCASE_K = 0x4B,
UPPERCASE_L = 0x4C,
UPPERCASE_M = 0x4D,
UPPERCASE_N = 0x4E,
UPPERCASE_O = 0x4F,
UPPERCASE_P = 0x50,
UPPERCASE_Q = 0x51,
UPPERCASE_R = 0x52,
UPPERCASE_S = 0x53,
UPPERCASE_T = 0x54,
UPPERCASE_U = 0x55,
UPPERCASE_V = 0x56,
UPPERCASE_W = 0x57,
UPPERCASE_X = 0x58,
UPPERCASE_Y = 0x59,
UPPERCASE_Z = 0x5A,
LEFT_SQUARE_BRACKET = 0x5B,
BACKSLASH = 0x5C,
RIGHT_SQUARE_BRACKET = 0x5D,
CARET = 0x5F,
GRAVE = 0x60,
LOWERCASE_A = 0x61,
LOWERCASE_B = 0x62,
LOWERCASE_C = 0x63,
LOWERCASE_D = 0x64,
LOWERCASE_E = 0x65,
LOWERCASE_F = 0x66,
LOWERCASE_G = 0x67,
LOWERCASE_H = 0x68,
LOWERCASE_I = 0x69,
LOWERCASE_J = 0x6A,
LOWERCASE_K = 0x6B,
LOWERCASE_L = 0x6C,
LOWERCASE_M = 0x6D,
LOWERCASE_N = 0x6E,
LOWERCASE_O = 0x6F,
LOWERCASE_P = 0x70,
LOWERCASE_Q = 0x71,
LOWERCASE_R = 0x72,
LOWERCASE_S = 0x73,
LOWERCASE_T = 0x74,
LOWERCASE_U = 0x75,
LOWERCASE_V = 0x76,
LOWERCASE_W = 0x77,
LOWERCASE_X = 0x78,
LOWERCASE_Y = 0x79,
LOWERCASE_Z = 0x7A,
LEFT_CURLY_BRACKET = 0x7B,
VERTICAL_BAR = 0x7C,
RIGHT_CURLY_BRACKET = 0x7D,
TILDE = 0x7E,
};
inline namespace tags {
VEG_TAG(from_raw_parts, FromRawParts);
VEG_TAG(safe, Safe);
VEG_TAG(unsafe, Unsafe);
} // namespace tags
struct Str
{
private:
struct
{
CharUnit const* ptr;
isize len;
} _ = {};
public:
VEG_INLINE constexpr Str(Unsafe /*unsafe*/,
FromRawParts /*from_raw_parts*/,
CharUnit const* ptr,
isize len) noexcept
: _{ ptr, len } {};
VEG_INLINE constexpr auto as_slice() const noexcept -> Slice<CharUnit>;
};
template<CharUnit... Cs>
struct StrLiteralConstant
{
private:
static constexpr CharUnit literal[sizeof...(Cs)] = { Cs... };
public:
VEG_INLINE constexpr auto as_slice() const noexcept -> Slice<CharUnit>;
VEG_INLINE constexpr auto as_str() const noexcept -> Str
{
return { unsafe, from_raw_parts, literal, isize{ sizeof...(Cs) } };
}
};
template<CharUnit... Cs>
constexpr CharUnit StrLiteralConstant<Cs...>::literal[sizeof...(Cs)];
namespace _detail {
using NativeChar8 = meta::uncvref_t<decltype(u8""[0])>;
template<typename T, usize N>
struct Array_
{
T _[N];
};
template<typename T>
constexpr auto
assert_complete() noexcept -> bool
{
static_assert(sizeof(T) != 0, ".");
return true;
}
} // namespace _detail
} // namespace veg
} // namespace linalg
} // namespace proxsuite
#if defined(__clang__) || (defined(VEG_WITH_CXX14_SUPPORT) && defined(__GNUC__))
HEDLEY_DIAGNOSTIC_PUSH
#pragma GCC diagnostic ignored "-Wpedantic"
#ifdef __clang__
#pragma clang diagnostic ignored "-Wgnu-string-literal-operator-template"
#endif
template<typename Char,
Char... Cs>
constexpr auto
operator""__veglib_const_literal_gnuc() noexcept // NOLINT
-> proxsuite::linalg::veg::StrLiteralConstant<
proxsuite::linalg::veg::CharUnit(Cs)...>
{
return {};
}
HEDLEY_DIAGNOSTIC_POP
#define __VEG_IMPL_UTF8_CONST(Literal) /* NOLINT */ \
(u8##Literal##__veglib_const_literal_gnuc)
#elif (defined(__clang__) && defined(VEG_WITH_CXX20_SUPPORT)) || \
(defined(__cpp_nontype_template_args) && \
(__cpp_nontype_template_args >= 201911L))
namespace proxsuite {
namespace linalg {
namespace veg {
namespace _detail {
template<isize N>
struct StrLiteralImpl
{
proxsuite::linalg::veg::CharUnit _[N];
template<typename Char>
constexpr StrLiteralImpl(Char const* s)
{
for (isize i = 0; i < N; ++i) {
_[i] = proxsuite::linalg::veg::CharUnit(s[i]);
}
}
};
template<typename Char, isize N>
StrLiteralImpl(Char const (&)[N]) -> StrLiteralImpl<N - 1>;
template<typename T>
struct StrLiteralLen;
template<isize N>
struct StrLiteralLen<StrLiteralImpl<N>>
{
static constexpr usize value{ N };
};
template<isize N>
struct StrLiteralLen<StrLiteralImpl<N> const>
{
static constexpr usize value{ N };
};
template<typename Seq, auto Literal>
struct StrLiteralExpand;
template<usize... Is, StrLiteralImpl<static_cast<isize>(sizeof...(Is))> L>
struct StrLiteralExpand<_meta::integer_sequence<usize, Is...>, L>
{
using Type = StrLiteralConstant<L._[Is]...>;
};
} // namespace _detail
} // namespace veg
} // namespace linalg
} // namespace proxsuite
template<proxsuite::linalg::veg::_detail::StrLiteralImpl S>
constexpr auto
operator""__veglib_const_literal_cpp20() noexcept ->
typename proxsuite::linalg::veg::_detail::StrLiteralExpand< //
proxsuite::linalg::veg::_detail::_meta::make_index_sequence<
proxsuite::linalg::veg::_detail::StrLiteralLen<decltype(S)>::value>,
S>::Type
{
return {};
}
#define __VEG_IMPL_UTF8_CONST(Literal) \
(u8##Literal##__veglib_const_literal_cpp20)
#else
namespace proxsuite {
namespace linalg {
namespace veg {
namespace _detail {
template<typename LiteralType, typename Seq>
struct ExtractCharsImpl;
template<typename LiteralType, usize... Is>
struct ExtractCharsImpl<LiteralType, _meta::integer_sequence<usize, Is...>>
{
using Type = StrLiteralConstant<CharUnit(LiteralType::value[Is])...>;
};
template<typename LiteralType, typename Seq>
struct ExtractCharsImplExpr;
template<typename LiteralType, usize... Is>
struct ExtractCharsImplExpr<LiteralType, _meta::integer_sequence<usize, Is...>>
{
using Type = StrLiteralConstant<CharUnit(LiteralType::value()[Is])...>;
};
template<typename LiteralType>
auto
extract_chars(LiteralType /*unused*/) -> typename ExtractCharsImpl<
LiteralType,
_meta::make_index_sequence<LiteralType::Size::value>>::Type
{
return {};
}
template<typename LiteralType>
auto
extract_chars_expr(LiteralType /*unused*/) -> typename ExtractCharsImplExpr<
LiteralType,
_meta::make_index_sequence<LiteralType::Size::value>>::Type
{
return {};
}
} // namespace _detail
} // namespace veg
} // namespace linalg
} // namespace proxsuite
#define __VEG_IMPL_UTF8_CONST(Literal) \
(::proxsuite::linalg::veg::_detail::extract_chars_expr( \
[]() /* NOLINT */ noexcept { \
struct __VEG_PP_CAT(_veglib_type, __LINE__) \
{ \
static constexpr auto value() noexcept -> decltype(Literal) \
{ \
return Literal; \
} \
using Size = ::proxsuite::linalg::veg::meta::constant< \
::proxsuite::linalg::veg::usize, \
sizeof(value()) / sizeof(value()[0]) - 1>; \
}; \
return __VEG_PP_CAT(_veglib_type, __LINE__){}; \
}()))
#endif
#define VEG_DECLTYPE_VOID(...) decltype(void(__VA_ARGS__))
#define VEG_BOOL_NOEXCEPT(...) \
::proxsuite::linalg::veg::meta::bool_constant<noexcept(__VA_ARGS__)>
#define VEG_CHECK_CONCEPT(...) \
VEG_CHECK_CONCEPT_MACRO(::proxsuite::linalg::veg::concepts, __VA_ARGS__)
#define VEG_CONCEPT(...) \
VEG_CONCEPT_MACRO(::proxsuite::linalg::veg::concepts, __VA_ARGS__)
#define __VEG_IMPL_GET_MEMBER_PTR(_, MemberPtr) /* NOLINT */ , &Type::MemberPtr
#define __VEG_IMPL_GET_MEMBER_NAME_PTR(_, MemberPtr) /* NOLINT */ \
static_cast<::proxsuite::linalg::veg::_detail::NativeChar8 const*>( \
__VEG_PP_CAT(u8, __VEG_PP_STRINGIZE(MemberPtr))),
#define __VEG_IMPL_GET_MEMBER_NAME_LEN(_, MemberPtr) /* NOLINT */ \
(sizeof(__VEG_PP_CAT(u8, __VEG_PP_STRINGIZE(MemberPtr))) - 1),
#define __VEG_IMPL_STRUCT_SETUP(PClass, ...) /* NOLINT */ \
void _veg_lib_name_test()&& noexcept \
{ \
static_assert( \
VEG_CONCEPT(same<decltype(this), __VEG_PP_REMOVE_PAREN(PClass)*>), \
"struct mismatch in VEG_REFLECT"); \
} \
struct _veglib_impl_member_extract \
{ \
using Type = __VEG_PP_REMOVE_PAREN(PClass); \
using MemberTuple = \
decltype(::proxsuite::linalg::veg::_detail::make_simple_tuple( \
::proxsuite::linalg::veg::_detail::Empty { \
} __VEG_PP_TUPLE_FOR_EACH(__VEG_IMPL_GET_MEMBER_PTR, \
_, \
(__VA_ARGS__)))); \
static constexpr auto member_pointers() noexcept -> MemberTuple \
{ \
return ::proxsuite::linalg::veg::_detail::make_simple_tuple( \
::proxsuite::linalg::veg::_detail::Empty {} __VEG_PP_TUPLE_FOR_EACH( \
__VEG_IMPL_GET_MEMBER_PTR, _, (__VA_ARGS__))); \
} \
static constexpr auto class_name_ptr() noexcept \
-> ::proxsuite::linalg::veg::_detail::NativeChar8 const* \
{ \
return __VEG_PP_CAT(u8, \
__VEG_PP_STRINGIZE(__VEG_PP_REMOVE_PAREN(PClass))); \
} \
static constexpr auto class_name_len() noexcept \
-> ::proxsuite::linalg::veg::usize \
{ \
return sizeof(__VEG_PP_CAT( \
u8, __VEG_PP_STRINGIZE(__VEG_PP_REMOVE_PAREN(PClass)))) - \
1; \
} \
static constexpr auto member_name_ptrs() noexcept \
-> ::proxsuite::linalg::veg::_detail::Array_< \
::proxsuite::linalg::veg::_detail::NativeChar8 const*, \
__VEG_PP_TUPLE_SIZE((__VA_ARGS__))> \
{ \
return { { __VEG_PP_TUPLE_FOR_EACH( \
__VEG_IMPL_GET_MEMBER_NAME_PTR, _, (__VA_ARGS__)) } }; \
} \
static constexpr auto member_name_lens() noexcept \
-> ::proxsuite::linalg::veg::_detail::Array_< \
::proxsuite::linalg::veg::usize, \
__VEG_PP_TUPLE_SIZE((__VA_ARGS__))> \
{ \
return { { __VEG_PP_TUPLE_FOR_EACH( \
__VEG_IMPL_GET_MEMBER_NAME_LEN, _, (__VA_ARGS__)) } }; \
} \
}; \
friend struct ::proxsuite::linalg::veg::_detail::member_extract_access< \
__VEG_PP_REMOVE_PAREN(PClass)>; \
VEG_NOM_SEMICOLON
#define VEG_REFLECT(PClass, ...) __VEG_IMPL_STRUCT_SETUP(PClass, __VA_ARGS__)
#include "proxsuite/linalg/veg/internal/epilogue.hpp"
#endif /* end of include guard VEG_MACROS_HPP_HSTLSKZXS */