godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use '_v' shorthand for type traits and 'if constexpr' where appropriate

This commit is contained in:
vittorioromeo 2024-02-02 15:43:21 +01:00
parent 10e111477d
commit 55ed34e37c
10 changed files with 41 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
core/object/class_db.h
View File

@ -188,7 +188,7 @@ public:
template <class T> template <class T>
static void register_class(bool p_virtual = false) { static void register_class(bool p_virtual = false) {
GLOBAL_LOCK_FUNCTION; GLOBAL_LOCK_FUNCTION;
static_assert(TypesAreSame<typename T::self_type, T>::value, "Class not declared properly, please use GDCLASS."); static_assert(types_are_same_v<typename T::self_type, T>, "Class not declared properly, please use GDCLASS.");
T::initialize_class(); T::initialize_class();
ClassInfo *t = classes.getptr(T::get_class_static()); ClassInfo *t = classes.getptr(T::get_class_static());
ERR_FAIL_NULL(t); ERR_FAIL_NULL(t);
@ -203,7 +203,7 @@ public:
template <class T> template <class T>
static void register_abstract_class() { static void register_abstract_class() {
GLOBAL_LOCK_FUNCTION; GLOBAL_LOCK_FUNCTION;
static_assert(TypesAreSame<typename T::self_type, T>::value, "Class not declared properly, please use GDCLASS."); static_assert(types_are_same_v<typename T::self_type, T>, "Class not declared properly, please use GDCLASS.");
T::initialize_class(); T::initialize_class();
ClassInfo *t = classes.getptr(T::get_class_static()); ClassInfo *t = classes.getptr(T::get_class_static());
ERR_FAIL_NULL(t); ERR_FAIL_NULL(t);
@ -216,7 +216,7 @@ public:
template <class T> template <class T>
static void register_internal_class() { static void register_internal_class() {
GLOBAL_LOCK_FUNCTION; GLOBAL_LOCK_FUNCTION;
static_assert(TypesAreSame<typename T::self_type, T>::value, "Class not declared properly, please use GDCLASS."); static_assert(types_are_same_v<typename T::self_type, T>, "Class not declared properly, please use GDCLASS.");
T::initialize_class(); T::initialize_class();
ClassInfo *t = classes.getptr(T::get_class_static()); ClassInfo *t = classes.getptr(T::get_class_static());
ERR_FAIL_NULL(t); ERR_FAIL_NULL(t);
@ -239,7 +239,7 @@ public:
template <class T> template <class T>
static void register_custom_instance_class() { static void register_custom_instance_class() {
GLOBAL_LOCK_FUNCTION; GLOBAL_LOCK_FUNCTION;
static_assert(TypesAreSame<typename T::self_type, T>::value, "Class not declared properly, please use GDCLASS."); static_assert(types_are_same_v<typename T::self_type, T>, "Class not declared properly, please use GDCLASS.");
T::initialize_class(); T::initialize_class();
ClassInfo *t = classes.getptr(T::get_class_static()); ClassInfo *t = classes.getptr(T::get_class_static());
ERR_FAIL_NULL(t); ERR_FAIL_NULL(t);
@ -296,7 +296,7 @@ public:
argptrs[i] = &args[i]; argptrs[i] = &args[i];
} }
MethodBind *bind = create_method_bind(p_method); MethodBind *bind = create_method_bind(p_method);
if constexpr (std::is_same<typename member_function_traits<M>::return_type, Object *>::value) { if constexpr (std::is_same_v<typename member_function_traits<M>::return_type, Object *>) {
bind->set_return_type_is_raw_object_ptr(true); bind->set_return_type_is_raw_object_ptr(true);
} }
return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, false, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args)); return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, false, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args));
@ -311,7 +311,7 @@ public:
} }
MethodBind *bind = create_static_method_bind(p_method); MethodBind *bind = create_static_method_bind(p_method);
bind->set_instance_class(p_class); bind->set_instance_class(p_class);
if constexpr (std::is_same<typename member_function_traits<M>::return_type, Object *>::value) { if constexpr (std::is_same_v<typename member_function_traits<M>::return_type, Object *>) {
bind->set_return_type_is_raw_object_ptr(true); bind->set_return_type_is_raw_object_ptr(true);
} }
return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, false, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args)); return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, false, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args));
@ -325,7 +325,7 @@ public:
argptrs[i] = &args[i]; argptrs[i] = &args[i];
} }
MethodBind *bind = create_method_bind(p_method); MethodBind *bind = create_method_bind(p_method);
if constexpr (std::is_same<typename member_function_traits<M>::return_type, Object *>::value) { if constexpr (std::is_same_v<typename member_function_traits<M>::return_type, Object *>) {
bind->set_return_type_is_raw_object_ptr(true); bind->set_return_type_is_raw_object_ptr(true);
} }
return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, true, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args)); return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, true, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args));
@ -340,7 +340,7 @@ public:
} }
MethodBind *bind = create_static_method_bind(p_method); MethodBind *bind = create_static_method_bind(p_method);
bind->set_instance_class(p_class); bind->set_instance_class(p_class);
if constexpr (std::is_same<typename member_function_traits<M>::return_type, Object *>::value) { if constexpr (std::is_same_v<typename member_function_traits<M>::return_type, Object *>) {
bind->set_return_type_is_raw_object_ptr(true); bind->set_return_type_is_raw_object_ptr(true);
} }
return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, true, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args)); return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, true, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args));
@ -353,7 +353,7 @@ public:
MethodBind *bind = create_vararg_method_bind(p_method, p_info, p_return_nil_is_variant); MethodBind *bind = create_vararg_method_bind(p_method, p_info, p_return_nil_is_variant);
ERR_FAIL_NULL_V(bind, nullptr); ERR_FAIL_NULL_V(bind, nullptr);
if constexpr (std::is_same<typename member_function_traits<M>::return_type, Object *>::value) { if constexpr (std::is_same_v<typename member_function_traits<M>::return_type, Object *>) {
bind->set_return_type_is_raw_object_ptr(true); bind->set_return_type_is_raw_object_ptr(true);
} }
return _bind_vararg_method(bind, p_name, p_default_args, false); return _bind_vararg_method(bind, p_name, p_default_args, false);
@ -366,7 +366,7 @@ public:
MethodBind *bind = create_vararg_method_bind(p_method, p_info, p_return_nil_is_variant); MethodBind *bind = create_vararg_method_bind(p_method, p_info, p_return_nil_is_variant);
ERR_FAIL_NULL_V(bind, nullptr); ERR_FAIL_NULL_V(bind, nullptr);
if constexpr (std::is_same<typename member_function_traits<M>::return_type, Object *>::value) { if constexpr (std::is_same_v<typename member_function_traits<M>::return_type, Object *>) {
bind->set_return_type_is_raw_object_ptr(true); bind->set_return_type_is_raw_object_ptr(true);
} }
return _bind_vararg_method(bind, p_name, p_default_args, true); return _bind_vararg_method(bind, p_name, p_default_args, true);

8
core/os/memory.h
View File

@ -105,7 +105,7 @@ void memdelete(T *p_class) {
if (!predelete_handler(p_class)) { if (!predelete_handler(p_class)) {
return; // doesn't want to be deleted return; // doesn't want to be deleted
} }
if (!std::is_trivially_destructible<T>::value) { if constexpr (!std::is_trivially_destructible_v<T>) {
p_class->~T(); p_class->~T();
} }
@ -117,7 +117,7 @@ void memdelete_allocator(T *p_class) {
if (!predelete_handler(p_class)) { if (!predelete_handler(p_class)) {
return; // doesn't want to be deleted return; // doesn't want to be deleted
} }
if (!std::is_trivially_destructible<T>::value) { if constexpr (!std::is_trivially_destructible_v<T>) {
p_class->~T(); p_class->~T();
} }
@ -147,7 +147,7 @@ T *memnew_arr_template(size_t p_elements) {
ERR_FAIL_NULL_V(mem, failptr); ERR_FAIL_NULL_V(mem, failptr);
*(mem - 1) = p_elements; *(mem - 1) = p_elements;
if (!std::is_trivially_constructible<T>::value) { if constexpr (!std::is_trivially_constructible_v<T>) {
T *elems = (T *)mem; T *elems = (T *)mem;
/* call operator new */ /* call operator new */
@ -174,7 +174,7 @@ template <typename T>
void memdelete_arr(T *p_class) { void memdelete_arr(T *p_class) {
uint64_t *ptr = (uint64_t *)p_class; uint64_t *ptr = (uint64_t *)p_class;
if (!std::is_trivially_destructible<T>::value) { if constexpr (!std::is_trivially_destructible_v<T>) {
uint64_t elem_count = *(ptr - 1); uint64_t elem_count = *(ptr - 1);
for (uint64_t i = 0; i < elem_count; i++) { for (uint64_t i = 0; i < elem_count; i++) {

8
core/templates/cowdata.h
View File

@ -233,7 +233,7 @@ void CowData<T>::_unref(void *p_data) {
} }
// clean up // clean up
if (!std::is_trivially_destructible<T>::value) { if constexpr (!std::is_trivially_destructible_v<T>) {
USize *count = _get_size(); USize *count = _get_size();
T *data = (T *)(count + 1); T *data = (T *)(count + 1);
@ -269,7 +269,7 @@ typename CowData<T>::USize CowData<T>::_copy_on_write() {
T *_data = (T *)(mem_new); T *_data = (T *)(mem_new);
// initialize new elements // initialize new elements
if (std::is_trivially_copyable<T>::value) { if constexpr (std::is_trivially_copyable_v<T>) {
memcpy(mem_new, _ptr, current_size * sizeof(T)); memcpy(mem_new, _ptr, current_size * sizeof(T));
} else { } else {
@ -335,7 +335,7 @@ Error CowData<T>::resize(Size p_size) {
// construct the newly created elements // construct the newly created elements
if (!std::is_trivially_constructible<T>::value) { if constexpr (!std::is_trivially_constructible_v<T>) {
for (Size i = *_get_size(); i < p_size; i++) { for (Size i = *_get_size(); i < p_size; i++) {
memnew_placement(&_ptr[i], T); memnew_placement(&_ptr[i], T);
} }
@ -346,7 +346,7 @@ Error CowData<T>::resize(Size p_size) {
*_get_size() = p_size; *_get_size() = p_size;
} else if (p_size < current_size) { } else if (p_size < current_size) {
if (!std::is_trivially_destructible<T>::value) { if constexpr (!std::is_trivially_destructible_v<T>) {
// deinitialize no longer needed elements // deinitialize no longer needed elements
for (USize i = p_size; i < *_get_size(); i++) { for (USize i = p_size; i < *_get_size(); i++) {
T *t = &_ptr[i]; T *t = &_ptr[i];

10
core/templates/local_vector.h
View File

@ -64,7 +64,7 @@ public:
CRASH_COND_MSG(!data, "Out of memory"); CRASH_COND_MSG(!data, "Out of memory");
} }
if constexpr (!std::is_trivially_constructible<T>::value && !force_trivial) { if constexpr (!std::is_trivially_constructible_v<T> && !force_trivial) {
memnew_placement(&data[count++], T(p_elem)); memnew_placement(&data[count++], T(p_elem));
} else { } else {
data[count++] = p_elem; data[count++] = p_elem;
@ -77,7 +77,7 @@ public:
for (U i = p_index; i < count; i++) { for (U i = p_index; i < count; i++) {
data[i] = data[i + 1]; data[i] = data[i + 1];
} }
if constexpr (!std::is_trivially_destructible<T>::value && !force_trivial) { if constexpr (!std::is_trivially_destructible_v<T> && !force_trivial) {
data[count].~T(); data[count].~T();
} }
} }
@ -90,7 +90,7 @@ public:
if (count > p_index) { if (count > p_index) {
data[p_index] = data[count]; data[p_index] = data[count];
} }
if constexpr (!std::is_trivially_destructible<T>::value && !force_trivial) { if constexpr (!std::is_trivially_destructible_v<T> && !force_trivial) {
data[count].~T(); data[count].~T();
} }
} }
@ -133,7 +133,7 @@ public:
_FORCE_INLINE_ U size() const { return count; } _FORCE_INLINE_ U size() const { return count; }
void resize(U p_size) { void resize(U p_size) {
if (p_size < count) { if (p_size < count) {
if constexpr (!std::is_trivially_destructible<T>::value && !force_trivial) { if constexpr (!std::is_trivially_destructible_v<T> && !force_trivial) {
for (U i = p_size; i < count; i++) { for (U i = p_size; i < count; i++) {
data[i].~T(); data[i].~T();
} }
@ -145,7 +145,7 @@ public:
data = (T *)memrealloc(data, capacity * sizeof(T)); data = (T *)memrealloc(data, capacity * sizeof(T));
CRASH_COND_MSG(!data, "Out of memory"); CRASH_COND_MSG(!data, "Out of memory");
} }
if constexpr (!std::is_trivially_constructible<T>::value && !force_trivial) { if constexpr (!std::is_trivially_constructible_v<T> && !force_trivial) {
for (U i = count; i < p_size; i++) { for (U i = count; i < p_size; i++) {
memnew_placement(&data[i], T); memnew_placement(&data[i], T);
} }

2
core/templates/paged_allocator.h
View File

@ -101,7 +101,7 @@ public:
private: private:
void _reset(bool p_allow_unfreed) { void _reset(bool p_allow_unfreed) {
if (!p_allow_unfreed || !std::is_trivially_destructible<T>::value) { if (!p_allow_unfreed || !std::is_trivially_destructible_v<T>) {
ERR_FAIL_COND(allocs_available < pages_allocated * page_size); ERR_FAIL_COND(allocs_available < pages_allocated * page_size);
} }
if (pages_allocated) { if (pages_allocated) {

10
core/templates/paged_array.h
View File

@ -202,7 +202,7 @@ public:
uint32_t page = count >> page_size_shift; uint32_t page = count >> page_size_shift;
uint32_t offset = count & page_size_mask; uint32_t offset = count & page_size_mask;
if (!std::is_trivially_constructible<T>::value) { if constexpr (!std::is_trivially_constructible_v<T>) {
memnew_placement(&page_data[page][offset], T(p_value)); memnew_placement(&page_data[page][offset], T(p_value));
} else { } else {
page_data[page][offset] = p_value; page_data[page][offset] = p_value;
@ -214,7 +214,7 @@ public:
_FORCE_INLINE_ void pop_back() { _FORCE_INLINE_ void pop_back() {
ERR_FAIL_COND(count == 0); ERR_FAIL_COND(count == 0);
if (!std::is_trivially_destructible<T>::value) { if constexpr (!std::is_trivially_destructible_v<T>) {
uint32_t page = (count - 1) >> page_size_shift; uint32_t page = (count - 1) >> page_size_shift;
uint32_t offset = (count - 1) & page_size_mask; uint32_t offset = (count - 1) & page_size_mask;
page_data[page][offset].~T(); page_data[page][offset].~T();
@ -237,7 +237,7 @@ public:
void clear() { void clear() {
//destruct if needed //destruct if needed
if (!std::is_trivially_destructible<T>::value) { if constexpr (!std::is_trivially_destructible_v<T>) {
for (uint64_t i = 0; i < count; i++) { for (uint64_t i = 0; i < count; i++) {
uint32_t page = i >> page_size_shift; uint32_t page = i >> page_size_shift;
uint32_t offset = i & page_size_mask; uint32_t offset = i & page_size_mask;
@ -318,13 +318,13 @@ public:
uint32_t to_copy = MIN(page_size - new_remainder, remainder); uint32_t to_copy = MIN(page_size - new_remainder, remainder);
for (uint32_t i = 0; i < to_copy; i++) { for (uint32_t i = 0; i < to_copy; i++) {
if (!std::is_trivially_constructible<T>::value) { if constexpr (!std::is_trivially_constructible_v<T>) {
memnew_placement(&dst_page[i + new_remainder], T(remainder_page[i + remainder - to_copy])); memnew_placement(&dst_page[i + new_remainder], T(remainder_page[i + remainder - to_copy]));
} else { } else {
dst_page[i + new_remainder] = remainder_page[i + remainder - to_copy]; dst_page[i + new_remainder] = remainder_page[i + remainder - to_copy];
} }
if (!std::is_trivially_destructible<T>::value) { if constexpr (!std::is_trivially_destructible_v<T>) {
remainder_page[i + remainder - to_copy].~T(); remainder_page[i + remainder - to_copy].~T();
} }
} }

2
core/templates/safe_refcount.h
View File

@ -54,7 +54,7 @@
#define SAFE_NUMERIC_TYPE_PUN_GUARANTEES(m_type) \ #define SAFE_NUMERIC_TYPE_PUN_GUARANTEES(m_type) \
static_assert(sizeof(SafeNumeric<m_type>) == sizeof(m_type)); \ static_assert(sizeof(SafeNumeric<m_type>) == sizeof(m_type)); \
static_assert(alignof(SafeNumeric<m_type>) == alignof(m_type)); \ static_assert(alignof(SafeNumeric<m_type>) == alignof(m_type)); \
static_assert(std::is_trivially_destructible<std::atomic<m_type>>::value); static_assert(std::is_trivially_destructible_v<std::atomic<m_type>>);
#define SAFE_FLAG_TYPE_PUN_GUARANTEES \ #define SAFE_FLAG_TYPE_PUN_GUARANTEES \
static_assert(sizeof(SafeFlag) == sizeof(bool)); \ static_assert(sizeof(SafeFlag) == sizeof(bool)); \
static_assert(alignof(SafeFlag) == alignof(bool)); static_assert(alignof(SafeFlag) == alignof(bool));

8
core/variant/binder_common.h
View File

@ -51,7 +51,7 @@ template <class T>
struct VariantCaster { struct VariantCaster {
static _FORCE_INLINE_ T cast(const Variant &p_variant) { static _FORCE_INLINE_ T cast(const Variant &p_variant) {
using TStripped = std::remove_pointer_t<T>; using TStripped = std::remove_pointer_t<T>;
if constexpr (std::is_base_of<Object, TStripped>::value) { if constexpr (std::is_base_of_v<Object, TStripped>) {
return Object::cast_to<TStripped>(p_variant); return Object::cast_to<TStripped>(p_variant);
} else { } else {
return p_variant; return p_variant;
@ -63,7 +63,7 @@ template <class T>
struct VariantCaster<T &> { struct VariantCaster<T &> {
static _FORCE_INLINE_ T cast(const Variant &p_variant) { static _FORCE_INLINE_ T cast(const Variant &p_variant) {
using TStripped = std::remove_pointer_t<T>; using TStripped = std::remove_pointer_t<T>;
if constexpr (std::is_base_of<Object, TStripped>::value) { if constexpr (std::is_base_of_v<Object, TStripped>) {
return Object::cast_to<TStripped>(p_variant); return Object::cast_to<TStripped>(p_variant);
} else { } else {
return p_variant; return p_variant;
@ -75,7 +75,7 @@ template <class T>
struct VariantCaster<const T &> { struct VariantCaster<const T &> {
static _FORCE_INLINE_ T cast(const Variant &p_variant) { static _FORCE_INLINE_ T cast(const Variant &p_variant) {
using TStripped = std::remove_pointer_t<T>; using TStripped = std::remove_pointer_t<T>;
if constexpr (std::is_base_of<Object, TStripped>::value) { if constexpr (std::is_base_of_v<Object, TStripped>) {
return Object::cast_to<TStripped>(p_variant); return Object::cast_to<TStripped>(p_variant);
} else { } else {
return p_variant; return p_variant;
@ -226,7 +226,7 @@ template <typename T>
struct VariantObjectClassChecker { struct VariantObjectClassChecker {
static _FORCE_INLINE_ bool check(const Variant &p_variant) { static _FORCE_INLINE_ bool check(const Variant &p_variant) {
using TStripped = std::remove_pointer_t<T>; using TStripped = std::remove_pointer_t<T>;
if constexpr (std::is_base_of<Object, TStripped>::value) { if constexpr (std::is_base_of_v<Object, TStripped>) {
Object *obj = p_variant; Object *obj = p_variant;
return Object::cast_to<TStripped>(p_variant) || !obj; return Object::cast_to<TStripped>(p_variant) || !obj;
} else { } else {

12
core/variant/type_info.h
View File

@ -43,14 +43,10 @@ struct EnableIf<false, T> {
}; };
template <typename, typename> template <typename, typename>
struct TypesAreSame { inline constexpr bool types_are_same_v = false;
static bool const value = false;
};
template <typename A> template <typename T>
struct TypesAreSame<A, A> { inline constexpr bool types_are_same_v<T, T> = true;
static bool const value = true;
};
template <typename B, typename D> template <typename B, typename D>
struct TypeInherits { struct TypeInherits {
@ -60,7 +56,7 @@ struct TypeInherits {
static char (&test(...))[2]; static char (&test(...))[2];
static bool const value = sizeof(test(get_d())) == sizeof(char) && static bool const value = sizeof(test(get_d())) == sizeof(char) &&
!TypesAreSame<B volatile const, void volatile const>::value; !types_are_same_v<B volatile const, void volatile const>;
}; };
namespace GodotTypeInfo { namespace GodotTypeInfo {

6
servers/rendering/storage/variant_converters.h
View File

@ -243,10 +243,10 @@ inline bool is_convertible_array(Variant::Type type) {
} }
template <class, class = void> template <class, class = void>
struct is_vector_type : std::false_type {}; inline constexpr bool is_vector_type_v = false;
template <class T> template <class T>
struct is_vector_type<T, std::void_t<decltype(T::AXIS_COUNT)>> : std::true_type {}; inline constexpr bool is_vector_type_v<T, std::void_t<decltype(T::AXIS_COUNT)>> = true;
template <typename T, typename P> template <typename T, typename P>
void convert_item_std140(const T &p_item, P *p_write, bool p_compact = false) { void convert_item_std140(const T &p_item, P *p_write, bool p_compact = false) {
@ -274,7 +274,7 @@ Vector<P> convert_array_std140(const Variant &p_variant, [[maybe_unused]] bool p
const Variant &item = array.get(i); const Variant &item = array.get(i);
P *offset = write + (i * elements); P *offset = write + (i * elements);
if constexpr (is_vector_type<T>::value) { if constexpr (is_vector_type_v<T>) {
const T &vec = convert_to_vector<T>(item, p_linear_color); const T &vec = convert_to_vector<T>(item, p_linear_color);
convert_item_std140<T, P>(vec, offset, true); convert_item_std140<T, P>(vec, offset, true);
} else { } else {