tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use *_t and *_v trait helpers from C++17 STL (#731)

Browse Source
This commit is contained in:
Bart Louwers
2023-01-26 10:10:33 +00:00
committed by GitHub
parent e94f0e9b1b
commit f7fa009f08
24 changed files with 58 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/mbgl/actor/actor_ref.hpp
View File

@@ -38,11 +38,7 @@ public:
template <typename Fn, class... Args>
auto ask(Fn fn, Args&&... args) const {
// Result type is deduced from the function's return type
#if __cplusplus >= 201703L
using ResultType = std::invoke_result_t<decltype(fn), Object, Args...>;
#else
using ResultType = typename std::result_of<decltype(fn)(Object, Args...)>::type;
#endif
std::promise<ResultType> promise;
auto future = promise.get_future();

12
include/mbgl/actor/established_actor.hpp
View File

@@ -28,10 +28,10 @@ template <class Object>
class EstablishedActor {
public:
// Construct the Object from a parameter pack `args` (i.e. `Object(args...)`)
template <typename U = Object, class... Args, typename std::enable_if<
std::is_constructible<U, Args...>::value ||
std::is_constructible<U, ActorRef<U>, Args...>::value
>::type * = nullptr>
template <typename U = Object, class... Args, typename std::enable_if_t<
std::is_constructible_v<U, Args...> ||
std::is_constructible_v<U, ActorRef<U>, Args...>
> * = nullptr>
EstablishedActor(Scheduler& scheduler, AspiringActor<Object>& parent_, Args&& ... args)
: parent(parent_) {
emplaceObject(std::forward<Args>(args)...);
@@ -56,13 +56,13 @@ public:
private:
// Enabled for Objects with a constructor taking ActorRef<Object> as the first parameter
template <typename U = Object, class... Args, typename std::enable_if<std::is_constructible<U, ActorRef<U>, Args...>::value>::type * = nullptr>
template <typename U = Object, class... Args, typename std::enable_if_t<std::is_constructible_v<U, ActorRef<U>, Args...>> * = nullptr>
void emplaceObject(Args&&... args_) {
new (&parent.objectStorage) Object(parent.self(), std::forward<Args>(args_)...);
}
// Enabled for plain Objects
template <typename U = Object, class... Args, typename std::enable_if<std::is_constructible<U, Args...>::value>::type * = nullptr>
template <typename U = Object, class... Args, typename std::enable_if_t<std::is_constructible_v<U, Args...>> * = nullptr>
void emplaceObject(Args&&... args_) {
new (&parent.objectStorage) Object(std::forward<Args>(args_)...);
}

6
include/mbgl/actor/message.hpp
View File

@@ -26,7 +26,7 @@ public:
}
void operator()() override {
invoke(std::make_index_sequence<std::tuple_size<ArgsTuple>::value>());
invoke(std::make_index_sequence<std::tuple_size_v<ArgsTuple>>());
}
template <std::size_t... I>
@@ -50,7 +50,7 @@ public:
}
void operator()() override {
promise.set_value(ask(std::make_index_sequence<std::tuple_size<ArgsTuple>::value>()));
promise.set_value(ask(std::make_index_sequence<std::tuple_size_v<ArgsTuple>>()));
}
template <std::size_t... I>
@@ -75,7 +75,7 @@ public:
}
void operator()() override {
ask(std::make_index_sequence<std::tuple_size<ArgsTuple>::value>());
ask(std::make_index_sequence<std::tuple_size_v<ArgsTuple>>());
promise.set_value();
}

2
include/mbgl/math/log2.hpp
View File

@@ -34,7 +34,7 @@ T log2(T x) {
defined(__ANDROID_API__) && __ANDROID_API__ < 18
template <typename T>
typename std::enable_if_t<std::is_floating_point<T>::value, T> log2(T x) {
typename std::enable_if_t<std::is_floating_point_v<T>, T> log2(T x) {
return ::log(x) / M_LN2;
}

12
include/mbgl/math/minmax.hpp
View File

@@ -8,32 +8,32 @@ namespace mbgl {
namespace util {
template <typename T>
typename std::enable_if_t<std::is_integral<T>::value, T> max(T a, T b) {
typename std::enable_if_t<std::is_integral_v<T>, T> max(T a, T b) {
return std::max(a, b);
}
template <typename T>
typename std::enable_if_t<std::is_floating_point<T>::value, T> max(T a, T b) {
typename std::enable_if_t<std::is_floating_point_v<T>, T> max(T a, T b) {
return ::fmax(a, b);
}
template <typename T, typename... Ts>
typename std::enable_if_t<std::is_arithmetic<T>::value, T> max(T a, T b, Ts... args) {
typename std::enable_if_t<std::is_arithmetic_v<T>, T> max(T a, T b, Ts... args) {
return max(a, max(b, args...));
}
template <typename T>
typename std::enable_if_t<std::is_integral<T>::value, T> min(T a, T b) {
typename std::enable_if_t<std::is_integral_v<T>, T> min(T a, T b) {
return std::min(a, b);
}
template <typename T>
typename std::enable_if_t<std::is_floating_point<T>::value, T> min(T a, T b) {
typename std::enable_if_t<std::is_floating_point_v<T>, T> min(T a, T b) {
return ::fmin(a, b);
}
template <typename T, typename... Ts>
typename std::enable_if_t<std::is_arithmetic<T>::value, T> min(T a, T b, Ts... args) {
typename std::enable_if_t<std::is_arithmetic_v<T>, T> min(T a, T b, Ts... args) {
return min(a, min(b, args...));
}

4
include/mbgl/style/conversion/constant.hpp
View File

@@ -30,12 +30,12 @@ struct Converter<std::string> {
};
template <class T>
struct Converter<T, typename std::enable_if_t<std::is_enum<T>::value>> {
struct Converter<T, typename std::enable_if_t<std::is_enum_v<T>>> {
optional<T> operator()(const Convertible& value, Error& error) const;
};
template <class T>
struct Converter<std::vector<T>, typename std::enable_if_t<std::is_enum<T>::value>> {
struct Converter<std::vector<T>, typename std::enable_if_t<std::is_enum_v<T>>> {
optional<std::vector<T>> operator()(const Convertible& value, Error& error) const;
};

6
include/mbgl/style/conversion_impl.hpp
View File

@@ -317,17 +317,17 @@ struct ValueFactory<Color> {
};
template <typename T>
struct ValueFactory<T, typename std::enable_if<(!std::is_enum<T>::value && !is_linear_container<T>::value)>::type> {
struct ValueFactory<T, typename std::enable_if_t<(!std::is_enum_v<T> && !is_linear_container<T>::value)>> {
static Value make(const T& arg) { return {arg}; }
};
template <typename T>
struct ValueFactory<T, typename std::enable_if<std::is_enum<T>::value>::type> {
struct ValueFactory<T, typename std::enable_if_t<std::is_enum_v<T>>> {
static Value make(T arg) { return {Enum<T>::toString(arg)}; }
};
template <typename T>
struct ValueFactory<T, typename std::enable_if<is_linear_container<T>::value>::type> {
struct ValueFactory<T, typename std::enable_if_t<is_linear_container<T>::value>> {
static Value make(const T& arg) {
mapbox::base::ValueArray result;
result.reserve(arg.size());

2
include/mbgl/style/expression/value.hpp
View File

@@ -128,7 +128,7 @@ struct ValueConverter<Position> {
};
template <typename T>
struct ValueConverter<T, std::enable_if_t< std::is_enum<T>::value >> {
struct ValueConverter<T, std::enable_if_t< std::is_enum_v<T> >> {
static type::Type expressionType() { return type::String; }
static Value toExpressionValue(const T& value);
static optional<T> fromExpressionValue(const Value& value);

2
include/mbgl/util/convert.hpp
View File

@@ -8,7 +8,7 @@ namespace mbgl {
namespace util {
template<typename To, typename From, std::size_t Size,
typename = std::enable_if_t<std::is_convertible<From, To>::value>>
typename = std::enable_if_t<std::is_convertible_v<From, To>>>
MBGL_CONSTEXPR std::array<To, Size> convert(const std::array<From, Size>&from) {
std::array<To, Size> to {{}};
std::copy(std::begin(from), std::end(from), std::begin(to));

4
include/mbgl/util/interpolate.hpp
View File

@@ -176,7 +176,7 @@ struct Interpolator<bool>
: Uninterpolated {};
template <class T>
struct Interpolator<T, typename std::enable_if_t<std::is_enum<T>::value>>
struct Interpolator<T, typename std::enable_if_t<std::is_enum_v<T>>>
: Uninterpolated {};
template <>
@@ -190,7 +190,7 @@ struct Interpolator<std::vector<T>>
template <class T>
struct Interpolatable
: std::conditional_t<
!std::is_base_of<Uninterpolated, Interpolator<T>>::value,
!std::is_base_of_v<Uninterpolated, Interpolator<T>>,
std::true_type,
std::false_type> {};

8
include/mbgl/util/string.hpp
View File

@@ -48,22 +48,22 @@ inline std::string toString(uint8_t t) {
return toString(static_cast<uint32_t>(t));
}
template <typename = std::enable_if<!std::is_same<uint64_t, unsigned long>::value>>
template <typename = std::enable_if<!std::is_same_v<uint64_t, unsigned long>>>
inline std::string toString(unsigned long t) {
return toString(static_cast<uint64_t>(t));
}
template <typename = std::enable_if<!std::is_same<uint64_t, unsigned long long>::value>>
template <typename = std::enable_if<!std::is_same_v<uint64_t, unsigned long long>>>
inline std::string toString(unsigned long long t) {
return toString(static_cast<uint64_t>(t));
}
template <typename = std::enable_if<!std::is_same<int64_t, long>::value>>
template <typename = std::enable_if<!std::is_same_v<int64_t, long>>>
inline std::string toString(long t) {
return toString(static_cast<int64_t>(t));
}
template <typename = std::enable_if<!std::is_same<int64_t, long long>::value>>
template <typename = std::enable_if<!std::is_same_v<int64_t, long long>>>
inline std::string toString(long long t) {
return toString(static_cast<int64_t>(t));
}

2
include/mbgl/util/traits.hpp
View File

@@ -18,7 +18,7 @@ template <> struct is_utf16char_like<char16_t>: std::true_type {};
template <> struct is_utf16char_like<wchar_t>: std::true_type {};
template <> struct is_utf16char_like<uint16_t>: std::true_type {};
template <typename T> using is_utf16char_like_pointer = std::integral_constant<bool, std::is_pointer<T>::value
template <typename T> using is_utf16char_like_pointer = std::integral_constant<bool, std::is_pointer_v<T>
&& is_utf16char_like<typename std::remove_pointer<T>::type>::value>;
template <class OutPointer, class InChar>

2
include/mbgl/util/work_task_impl.hpp
View File

@@ -20,7 +20,7 @@ public:
// Lock the mutex while processing so that cancel() will block.
std::lock_guard<std::recursive_mutex> lock(mutex);
if (!*canceled) {
invoke(std::make_index_sequence<std::tuple_size<P>::value>{});
invoke(std::make_index_sequence<std::tuple_size_v<P>>{});
}
}