RPCS3/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2024-11-24 03:32:50 +01:00
Code Issues Releases Wiki Activity

simplify template code like std::is_same<T>::value

Browse Source
This commit is contained in:
oltolm 2024-03-20 17:16:49 +01:00 committed by Elad Ashkenazi
parent c268189e38
commit 9e9a3262eb
26 changed files with 111 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Utilities/StrFmt.cpp
View File

@ -518,7 +518,7 @@ struct fmt::cfmt_src
TYPE(llong);
TYPE(schar);
TYPE(short);
if (std::is_signed<char>::value) TYPE(char);
if (std::is_signed_v<char>) TYPE(char);
TYPE(long);
TYPE(s128);

6
Utilities/StrFmt.h
View File

@ -54,7 +54,7 @@ struct fmt_unveil
};
template <typename T>
struct fmt_unveil<T, std::enable_if_t<std::is_integral<T>::value && sizeof(T) <= 8 && alignof(T) <= 8>>
struct fmt_unveil<T, std::enable_if_t<std::is_integral_v<T> && sizeof(T) <= 8 && alignof(T) <= 8>>
{
using type = T;
@ -65,7 +65,7 @@ struct fmt_unveil<T, std::enable_if_t<std::is_integral<T>::value && sizeof(T) <=
};
template <typename T>
struct fmt_unveil<T, std::enable_if_t<std::is_floating_point<T>::value && sizeof(T) <= 8 && alignof(T) <= 8>>
struct fmt_unveil<T, std::enable_if_t<std::is_floating_point_v<T> && sizeof(T) <= 8 && alignof(T) <= 8>>
{
using type = T;
@ -77,7 +77,7 @@ struct fmt_unveil<T, std::enable_if_t<std::is_floating_point<T>::value && sizeof
};
template <typename T>
struct fmt_unveil<T, std::enable_if_t<std::is_enum<T>::value>>
struct fmt_unveil<T, std::enable_if_t<std::is_enum_v<T>>>
{
using type = T;

4
Utilities/bit_set.h
View File

@ -60,9 +60,9 @@ public:
static constexpr usz bitmax = sizeof(T) * 8;
static constexpr usz bitsize = static_cast<under>(T::__bitset_enum_max);
static_assert(std::is_enum<T>::value, "bs_t<> error: invalid type (must be enum)");
static_assert(std::is_enum_v<T>, "bs_t<> error: invalid type (must be enum)");
static_assert(bitsize <= bitmax, "bs_t<> error: invalid __bitset_enum_max");
static_assert(bitsize != bitmax || std::is_unsigned<under>::value, "bs_t<> error: invalid __bitset_enum_max (sign bit)");
static_assert(bitsize != bitmax || std::is_unsigned_v<under>, "bs_t<> error: invalid __bitset_enum_max (sign bit)");
// Helper function
static constexpr under shift(T value)

4
rpcs3/Emu/CPU/CPUTranslator.h
View File

@ -125,7 +125,7 @@ using get_int_vt = typename get_int_bits<Bits>::utype;
template <typename T = void>
struct llvm_value_t
{
static_assert(std::is_same<T, void>::value, "llvm_value_t<> error: unknown type");
static_assert(std::is_same_v<T, void>, "llvm_value_t<> error: unknown type");
using type = void;
using base = llvm_value_t;
@ -417,7 +417,7 @@ struct llvm_value_t<f64> : llvm_value_t<void>
template <typename T>
struct llvm_value_t<T*> : llvm_value_t<T>
{
static_assert(!std::is_void<T>::value, "llvm_value_t<> error: invalid pointer to void type");
static_assert(!std::is_void_v<T>, "llvm_value_t<> error: invalid pointer to void type");
using type = T*;
using base = llvm_value_t<T>;

12
rpcs3/Emu/Cell/Modules/cellGem.cpp
View File

@ -804,11 +804,11 @@ static void ds3_pos_to_gem_state(u32 gem_num, const gem_config::gem_controller&
s32 ds3_pos_x, ds3_pos_y;
ds3_get_stick_values(gem_num, pad, ds3_pos_x, ds3_pos_y);
if constexpr (std::is_same<T, vm::ptr<CellGemState>>::value)
if constexpr (std::is_same_v<T, vm::ptr<CellGemState>>)
{
pos_to_gem_state(gem_num, controller, gem_state, ds3_pos_x, ds3_pos_y, ds3_max_x, ds3_max_y);
}
else if constexpr (std::is_same<T, vm::ptr<CellGemImageState>>::value)
else if constexpr (std::is_same_v<T, vm::ptr<CellGemImageState>>)
{
pos_to_gem_image_state(gem_num, controller, gem_state, ds3_pos_x, ds3_pos_y, ds3_max_x, ds3_max_y);
}
@ -947,11 +947,11 @@ static void mouse_pos_to_gem_state(const u32 mouse_no, const gem_config::gem_con
const auto& mouse = ::at32(handler.GetMice(), mouse_no);
if constexpr (std::is_same<T, vm::ptr<CellGemState>>::value)
if constexpr (std::is_same_v<T, vm::ptr<CellGemState>>)
{
pos_to_gem_state(mouse_no, controller, gem_state, mouse.x_pos, mouse.y_pos, mouse.x_max, mouse.y_max);
}
else if constexpr (std::is_same<T, vm::ptr<CellGemImageState>>::value)
else if constexpr (std::is_same_v<T, vm::ptr<CellGemImageState>>)
{
pos_to_gem_image_state(mouse_no, controller, gem_state, mouse.x_pos, mouse.y_pos, mouse.x_max, mouse.y_max);
}
@ -1015,11 +1015,11 @@ static void gun_pos_to_gem_state(const u32 gem_no, const gem_config::gem_control
y_max = gun.handler.get_axis_y_max(gem_no);
}
if constexpr (std::is_same<T, vm::ptr<CellGemState>>::value)
if constexpr (std::is_same_v<T, vm::ptr<CellGemState>>)
{
pos_to_gem_state(gem_no, controller, gem_state, x_pos, y_pos, x_max, y_max);
}
else if constexpr (std::is_same<T, vm::ptr<CellGemImageState>>::value)
else if constexpr (std::is_same_v<T, vm::ptr<CellGemImageState>>)
{
pos_to_gem_image_state(gem_no, controller, gem_state, x_pos, y_pos, x_max, y_max);
}

4
rpcs3/Emu/Cell/Modules/sceNp.cpp
View File

@ -5834,8 +5834,8 @@ error_code scenp_score_get_ranking_by_npid(s32 transId, SceNpScoreBoardId boardI
std::vector<std::pair<SceNpId, s32>> npid_vec;
static constexpr bool is_npid = std::is_same<T, vm::cptr<SceNpId>>::value;
static constexpr bool is_npidpcid = std::is_same<T, vm::cptr<SceNpScoreNpIdPcId>>::value;
static constexpr bool is_npid = std::is_same_v<T, vm::cptr<SceNpId>>;
static constexpr bool is_npidpcid = std::is_same_v<T, vm::cptr<SceNpScoreNpIdPcId>>;
static_assert(is_npid || is_npidpcid, "T should be vm::cptr<SceNpId> or vm::cptr<SceNpScoreNpIdPcId>");
if constexpr (is_npid)

24
rpcs3/Emu/Cell/PPUCallback.h
View File

@ -27,8 +27,8 @@ namespace ppu_cb_detail
struct _func_arg
{
static_assert(type == ARG_GENERAL, "Unknown callback argument type");
static_assert(!std::is_pointer<T>::value, "Invalid callback argument type (pointer)");
static_assert(!std::is_reference<T>::value, "Invalid callback argument type (reference)");
static_assert(!std::is_pointer_v<T>, "Invalid callback argument type (pointer)");
static_assert(!std::is_reference_v<T>, "Invalid callback argument type (reference)");
static_assert(sizeof(T) <= 8, "Invalid callback argument type for ARG_GENERAL");
static inline void set_value(ppu_thread& CPU, const T& arg)
@ -51,7 +51,7 @@ namespace ppu_cb_detail
template<typename T, u32 g_count, u32 f_count, u32 v_count>
struct _func_arg<T, ARG_VECTOR, g_count, f_count, v_count>
{
static_assert(std::is_same<std::decay_t<T>, v128>::value, "Invalid callback argument type for ARG_VECTOR");
static_assert(std::is_same_v<std::decay_t<T>, v128>, "Invalid callback argument type for ARG_VECTOR");
static inline void set_value(ppu_thread& CPU, const T& arg)
{
@ -75,7 +75,7 @@ namespace ppu_cb_detail
template<typename T, u32 g_count, u32 f_count, u32 v_count>
struct _func_arg<T, ARG_CONTEXT, g_count, f_count, v_count>
{
static_assert(std::is_same<std::decay_t<T>, ppu_thread>::value, "Invalid callback argument type for ARG_CONTEXT");
static_assert(std::is_same_v<std::decay_t<T>, ppu_thread>, "Invalid callback argument type for ARG_CONTEXT");
FORCE_INLINE static void set_value(ppu_thread&, const T&)
{
@ -92,9 +92,9 @@ namespace ppu_cb_detail
template<u32 g_count, u32 f_count, u32 v_count, typename T1, typename... T>
FORCE_INLINE static bool _bind_func_args(ppu_thread& CPU, T1 arg1, T... args)
{
const bool is_float = std::is_floating_point<T1>::value;
const bool is_vector = std::is_same<std::decay_t<T1>, v128>::value;
const bool is_context = std::is_same<std::decay_t<T1>, ppu_thread>::value;
const bool is_float = std::is_floating_point_v<T1>;
const bool is_vector = std::is_same_v<std::decay_t<T1>, v128>;
const bool is_context = std::is_same_v<std::decay_t<T1>, ppu_thread>;
const bool is_general = !is_float && !is_vector && !is_context;
const _func_arg_type t =
@ -140,7 +140,7 @@ namespace ppu_cb_detail
template<typename T>
struct _func_res<T, ARG_VECTOR>
{
static_assert(std::is_same<std::decay_t<T>, v128>::value, "Invalid callback result type for ARG_VECTOR");
static_assert(std::is_same_v<std::decay_t<T>, v128>, "Invalid callback result type for ARG_VECTOR");
FORCE_INLINE static T get_value(const ppu_thread& CPU)
{
@ -155,10 +155,10 @@ namespace ppu_cb_detail
{
_func_caller<void, T...>::call(CPU, pc, rtoc, args...);
static_assert(!std::is_pointer<RT>::value, "Invalid callback result type (pointer)");
static_assert(!std::is_reference<RT>::value, "Invalid callback result type (reference)");
const bool is_float = std::is_floating_point<RT>::value;
const bool is_vector = std::is_same<std::decay_t<RT>, v128>::value;
static_assert(!std::is_pointer_v<RT>, "Invalid callback result type (pointer)");
static_assert(!std::is_reference_v<RT>, "Invalid callback result type (reference)");
const bool is_float = std::is_floating_point_v<RT>;
const bool is_vector = std::is_same_v<std::decay_t<RT>, v128>;
const _func_arg_type t = is_float ? ARG_FLOAT : (is_vector ? ARG_VECTOR : ARG_GENERAL);
return _func_res<RT, t>::get_value(CPU);

28
rpcs3/Emu/Cell/PPUFunction.h
View File

@ -47,8 +47,8 @@ namespace ppu_func_detail
struct bind_arg
{
static_assert(type == ARG_GENERAL, "Unknown function argument type");
static_assert(!std::is_pointer<T>::value, "Invalid function argument type (pointer)");
static_assert(!std::is_reference<T>::value, "Invalid function argument type (reference)");
static_assert(!std::is_pointer_v<T>, "Invalid function argument type (pointer)");
static_assert(!std::is_reference_v<T>, "Invalid function argument type (reference)");
static_assert(sizeof(T) <= 8, "Invalid function argument type for ARG_GENERAL");
static inline T get_arg(ppu_thread& ppu)
@ -71,7 +71,7 @@ namespace ppu_func_detail
template<typename T, u32 g_count, u32 f_count, u32 v_count>
struct bind_arg<T, ARG_VECTOR, g_count, f_count, v_count>
{
static_assert(std::is_same<std::decay_t<T>, v128>::value, "Invalid function argument type for ARG_VECTOR");
static_assert(std::is_same_v<std::decay_t<T>, v128>, "Invalid function argument type for ARG_VECTOR");
static FORCE_INLINE T get_arg(ppu_thread& ppu)
{
@ -93,7 +93,7 @@ namespace ppu_func_detail
template<typename T, u32 g_count, u32 f_count, u32 v_count>
struct bind_arg<T, ARG_CONTEXT, g_count, f_count, v_count>
{
static_assert(std::is_base_of<std::decay_t<T>, ppu_thread>::value, "Invalid function argument type for ARG_CONTEXT");
static_assert(std::is_base_of_v<std::decay_t<T>, ppu_thread>, "Invalid function argument type for ARG_CONTEXT");
static FORCE_INLINE T& get_arg(ppu_thread& ppu)
{
@ -104,7 +104,7 @@ namespace ppu_func_detail
template<typename T, u32 g_count, u32 f_count, u32 v_count>
struct bind_arg<T, ARG_VARIADIC, g_count, f_count, v_count>
{
static_assert(std::is_same<std::decay_t<T>, ppu_va_args_t>::value, "Invalid function argument type for ARG_VARIADIC");
static_assert(std::is_same_v<std::decay_t<T>, ppu_va_args_t>, "Invalid function argument type for ARG_VARIADIC");
static FORCE_INLINE ppu_va_args_t get_arg(ppu_thread&)
{
@ -140,7 +140,7 @@ namespace ppu_func_detail
template<typename T>
struct bind_result<T, ARG_VECTOR>
{
static_assert(std::is_same<std::decay_t<T>, v128>::value, "Invalid function result type for ARG_VECTOR");
static_assert(std::is_same_v<std::decay_t<T>, v128>, "Invalid function result type for ARG_VECTOR");
static FORCE_INLINE void put_result(ppu_thread& ppu, const T& result)
{
@ -192,10 +192,10 @@ namespace ppu_func_detail
const u32 v_count = (info.last_value >> 24);
// TODO: check calculations
const bool is_float = std::is_floating_point<T>::value;
const bool is_vector = std::is_same<std::decay_t<T>, v128>::value;
const bool is_context = std::is_base_of<std::decay_t<T>, ppu_thread>::value;
const bool is_variadic = std::is_same<std::decay_t<T>, ppu_va_args_t>::value;
const bool is_float = std::is_floating_point_v<T>;
const bool is_vector = std::is_same_v<std::decay_t<T>, v128>;
const bool is_context = std::is_base_of_v<std::decay_t<T>, ppu_thread>;
const bool is_variadic = std::is_same_v<std::decay_t<T>, ppu_va_args_t>;
const bool is_general = !is_float && !is_vector && !is_context && !is_variadic;
const arg_class t =
@ -216,10 +216,10 @@ namespace ppu_func_detail
template<typename RT>
struct result_type
{
static_assert(!std::is_pointer<RT>::value, "Invalid function result type (pointer)");
static_assert(!std::is_reference<RT>::value, "Invalid function result type (reference)");
static const bool is_float = std::is_floating_point<RT>::value;
static const bool is_vector = std::is_same<std::decay_t<RT>, v128>::value;
static_assert(!std::is_pointer_v<RT>, "Invalid function result type (pointer)");
static_assert(!std::is_reference_v<RT>, "Invalid function result type (reference)");
static const bool is_float = std::is_floating_point_v<RT>;
static const bool is_vector = std::is_same_v<std::decay_t<RT>, v128>;
static const arg_class value = is_float ? ARG_FLOAT : (is_vector ? ARG_VECTOR : ARG_GENERAL);
};

2
rpcs3/Emu/Cell/PPUModule.h
View File

@ -147,7 +147,7 @@ public:
{
using gvar = std::decay_t<decltype(*Var)>;
static_assert(std::is_same<u32, typename gvar::addr_type>::value, "Static variable registration: vm::gvar<T> expected");
static_assert(std::is_same_v<u32, typename gvar::addr_type>, "Static variable registration: vm::gvar<T> expected");
auto& info = access_static_variable(_module, vnid);

4
rpcs3/Emu/Cell/PPUThread.h
View File

@ -385,10 +385,10 @@ struct ppu_gpr_cast_impl
};
template<typename T>
struct ppu_gpr_cast_impl<T, std::enable_if_t<std::is_integral<T>::value || std::is_enum<T>::value>>
struct ppu_gpr_cast_impl<T, std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>>
{
static_assert(sizeof(T) <= 8, "Too big integral type for ppu_gpr_cast<>()");
static_assert(std::is_same<std::decay_t<T>, bool>::value == false, "bool type is deprecated in ppu_gpr_cast<>(), use b8 instead");
static_assert(std::is_same_v<std::decay_t<T>, bool> == false, "bool type is deprecated in ppu_gpr_cast<>(), use b8 instead");
static inline u64 to(const T& value)
{

2
rpcs3/Emu/IdManager.h
View File

@ -488,7 +488,7 @@ class idm
if (data.second)
{
if (std::is_same<T, Type>::value || data.first.type() == get_type<Type>())
if (std::is_same_v<T, Type> || data.first.type() == get_type<Type>())
{
if (!id_manager::id_traits<Type>::invl_range.second || data.first.value() == id)
{

4
rpcs3/Emu/Memory/vm_ptr.h
View File

@ -22,8 +22,8 @@ namespace vm
{
AT m_addr;
static_assert(!std::is_pointer<T>::value, "vm::_ptr_base<> error: invalid type (pointer)");
static_assert(!std::is_reference<T>::value, "vm::_ptr_base<> error: invalid type (reference)");
static_assert(!std::is_pointer_v<T>, "vm::_ptr_base<> error: invalid type (pointer)");
static_assert(!std::is_reference_v<T>, "vm::_ptr_base<> error: invalid type (reference)");
public:
using type = T;

8
rpcs3/Emu/Memory/vm_ref.h
View File

@ -20,10 +20,10 @@ namespace vm
{
AT m_addr;
static_assert(!std::is_pointer<T>::value, "vm::_ref_base<> error: invalid type (pointer)");
static_assert(!std::is_reference<T>::value, "vm::_ref_base<> error: invalid type (reference)");
static_assert(!std::is_function<T>::value, "vm::_ref_base<> error: invalid type (function)");
static_assert(!std::is_void<T>::value, "vm::_ref_base<> error: invalid type (void)");
static_assert(!std::is_pointer_v<T>, "vm::_ref_base<> error: invalid type (pointer)");
static_assert(!std::is_reference_v<T>, "vm::_ref_base<> error: invalid type (reference)");
static_assert(!std::is_function_v<T>, "vm::_ref_base<> error: invalid type (function)");
static_assert(!std::is_void_v<T>, "vm::_ref_base<> error: invalid type (void)");
public:
using type = T;

2
rpcs3/Emu/RSX/Common/BufferUtils.cpp
View File

@ -435,7 +435,7 @@ std::tuple<T, T, u32> upload_untouched(std::span<to_be_t<const T>> src, std::spa
{
return untouched_impl::upload_untouched(src, dst);
}
else if constexpr (std::is_same<T, u16>::value)
else if constexpr (std::is_same_v<T, u16>)
{
if (primitive_restart_index > 0xffff)
{

2
rpcs3/Emu/RSX/Common/TextureUtils.cpp
View File

@ -224,7 +224,7 @@ struct copy_unmodified_block_swizzled
template<typename T, typename U>
static void copy_mipmap_level(std::span<T> dst, std::span<const U> src, u16 words_per_block, u16 width_in_block, u16 row_count, u16 depth, u8 border, u32 dst_pitch_in_block)
{
if (std::is_same<T, U>::value && dst_pitch_in_block == width_in_block && words_per_block == 1 && !border)
if (std::is_same_v<T, U> && dst_pitch_in_block == width_in_block && words_per_block == 1 && !border)
{
rsx::convert_linear_swizzle_3d<T>(src.data(), dst.data(), width_in_block, row_count, depth);
}

5
rpcs3/Emu/RSX/Common/texture_cache.h
View File

@ -1,5 +1,8 @@
#pragma once
#include "Emu/RSX/Common/simple_array.hpp"
#include "Emu/RSX/Core/RSXContext.h"
#include "Emu/RSX/RSXThread.h"
#include "texture_cache_utils.h"
#include "texture_cache_predictor.h"
#include "texture_cache_helpers.h"
@ -35,7 +38,7 @@ namespace rsx
using copy_region_descriptor = copy_region_descriptor_base<typename traits::image_resource_type>;
private:
static_assert(std::is_base_of<rsx::cached_texture_section<section_storage_type, traits>, section_storage_type>::value, "section_storage_type must derive from rsx::cached_texture_section");
static_assert(std::is_base_of_v<rsx::cached_texture_section<section_storage_type, traits>, section_storage_type>, "section_storage_type must derive from rsx::cached_texture_section");
/**
* Helper structs/enums

1
rpcs3/Emu/RSX/Core/RSXContext.h
View File

@ -3,6 +3,7 @@
#include <util/types.hpp>
#include "Emu/Cell/lv2/sys_rsx.h"
#include "Emu/RSX/GCM.h"
#include "Emu/RSX/rsx_utils.h"
#include "RSXIOMap.hpp"
namespace rsx

2
rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_components.h
View File

@ -157,7 +157,7 @@ namespace rsx
return;
}
if constexpr (std::is_floating_point<T>::value)
if constexpr (std::is_floating_point_v<T>)
{
m_value_label.set_text(fmt::format("%.2f%s", this->m_last_value, m_suffix));
}

6
rpcs3/Emu/RSX/Program/FragmentProgramDecompiler.cpp
View File

@ -497,15 +497,15 @@ template<typename T> std::string FragmentProgramDecompiler::GetSRC(T src)
std::string ret;
u32 precision_modifier = 0;
if constexpr (std::is_same<T, SRC0>::value)
if constexpr (std::is_same_v<T, SRC0>)
{
precision_modifier = src1.src0_prec_mod;
}
else if constexpr (std::is_same<T, SRC1>::value)
else if constexpr (std::is_same_v<T, SRC1>)
{
precision_modifier = src1.src1_prec_mod;
}
else if constexpr (std::is_same<T, SRC2>::value)
else if constexpr (std::is_same_v<T, SRC2>)
{
precision_modifier = src1.src2_prec_mod;
}

8
rpcs3/Loader/ELF.h
View File

@ -288,11 +288,11 @@ public:
return set_error(elf_error::header_magic);
// Check class
if (header.e_class != (std::is_same<sz_t, u32>::value ? 1 : 2))
if (header.e_class != (std::is_same_v<sz_t, u32> ? 1 : 2))
return set_error(elf_error::header_class);
// Check endianness
if (header.e_data != (std::is_same<en_t<u32>, le_t<u32>>::value ? 1 : 2))
if (header.e_data != (std::is_same_v<en_t<u32>, le_t<u32>> ? 1 : 2))
return set_error(elf_error::header_endianness);
// Check machine
@ -413,8 +413,8 @@ public:
// Write header
ehdr_t header{};
header.e_magic = "\177ELF"_u32;
header.e_class = std::is_same<sz_t, u32>::value ? 1 : 2;
header.e_data = std::is_same<en_t<u32>, le_t<u32>>::value ? 1 : 2;
header.e_class = std::is_same_v<sz_t, u32> ? 1 : 2;
header.e_data = std::is_same_v<en_t<u32>, le_t<u32>> ? 1 : 2;
header.e_curver = 1;
header.e_os_abi = OS != elf_os::none ? OS : this->header.e_os_abi;
header.e_abi_ver = this->header.e_abi_ver;

16
rpcs3/rpcs3qt/cheat_manager.cpp
View File

@ -889,7 +889,7 @@ T cheat_manager_dialog::convert_from_QString(const QString& str, bool& success)
{
T result;
if constexpr (std::is_same<T, u8>::value)
if constexpr (std::is_same_v<T, u8>)
{
const u16 result_16 = str.toUShort(&success);
@ -899,16 +899,16 @@ T cheat_manager_dialog::convert_from_QString(const QString& str, bool& success)
result = static_cast<T>(result_16);
}
if constexpr (std::is_same<T, u16>::value)
if constexpr (std::is_same_v<T, u16>)
result = str.toUShort(&success);
if constexpr (std::is_same<T, u32>::value)
if constexpr (std::is_same_v<T, u32>)
result = str.toUInt(&success);
if constexpr (std::is_same<T, u64>::value)
if constexpr (std::is_same_v<T, u64>)
result = str.toULongLong(&success);
if constexpr (std::is_same<T, s8>::value)
if constexpr (std::is_same_v<T, s8>)
{
const s16 result_16 = str.toShort(&success);
if (result_16 < -128 || result_16 > 127)
@ -917,13 +917,13 @@ T cheat_manager_dialog::convert_from_QString(const QString& str, bool& success)
result = static_cast<T>(result_16);
}
if constexpr (std::is_same<T, s16>::value)
if constexpr (std::is_same_v<T, s16>)
result = str.toShort(&success);
if constexpr (std::is_same<T, s32>::value)
if constexpr (std::is_same_v<T, s32>)
result = str.toInt(&success);
if constexpr (std::is_same<T, s64>::value)
if constexpr (std::is_same_v<T, s64>)
result = str.toLongLong(&success);
return result;

44
rpcs3/util/atomic.hpp
View File

@ -1338,7 +1338,7 @@ public:
auto fetch_add(const ptr_rt& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::fetch_add(m_data, rhs);
}
@ -1351,7 +1351,7 @@ public:
auto add_fetch(const ptr_rt& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::add_fetch(m_data, rhs);
}
@ -1365,7 +1365,7 @@ public:
auto operator +=(const ptr_rt& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::add_fetch(m_data, rhs);
}
@ -1378,7 +1378,7 @@ public:
auto fetch_sub(const ptr_rt& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::fetch_sub(m_data, rhs);
}
@ -1391,7 +1391,7 @@ public:
auto sub_fetch(const ptr_rt& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::sub_fetch(m_data, rhs);
}
@ -1405,7 +1405,7 @@ public:
auto operator -=(const ptr_rt& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::sub_fetch(m_data, rhs);
}
@ -1418,7 +1418,7 @@ public:
auto fetch_and(const type& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::fetch_and(m_data, rhs);
}
@ -1431,7 +1431,7 @@ public:
auto and_fetch(const type& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::and_fetch(m_data, rhs);
}
@ -1445,7 +1445,7 @@ public:
auto operator &=(const type& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::and_fetch(m_data, rhs);
}
@ -1458,7 +1458,7 @@ public:
auto fetch_or(const type& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::fetch_or(m_data, rhs);
}
@ -1471,7 +1471,7 @@ public:
auto or_fetch(const type& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::or_fetch(m_data, rhs);
}
@ -1485,7 +1485,7 @@ public:
auto operator |=(const type& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::or_fetch(m_data, rhs);
}
@ -1498,7 +1498,7 @@ public:
auto fetch_xor(const type& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::fetch_xor(m_data, rhs);
}
@ -1511,7 +1511,7 @@ public:
auto xor_fetch(const type& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::xor_fetch(m_data, rhs);
}
@ -1525,7 +1525,7 @@ public:
auto operator ^=(const type& rhs)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::xor_fetch(m_data, rhs);
}
@ -1538,7 +1538,7 @@ public:
auto operator ++()
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::inc_fetch(m_data);
}
@ -1551,7 +1551,7 @@ public:
auto operator --()
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::dec_fetch(m_data);
}
@ -1564,7 +1564,7 @@ public:
auto operator ++(int)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::fetch_inc(m_data);
}
@ -1577,7 +1577,7 @@ public:
auto operator --(int)
{
if constexpr(std::is_integral<type>::value)
if constexpr(std::is_integral_v<type>)
{
return atomic_storage<type>::fetch_dec(m_data);
}
@ -1636,7 +1636,7 @@ public:
bool bit_test_set(uint bit)
{
if constexpr (std::is_integral<type>::value)
if constexpr (std::is_integral_v<type>)
{
return atomic_storage<type>::bts(m_data, bit & (sizeof(T) * 8 - 1));
}
@ -1652,7 +1652,7 @@ public:
bool bit_test_reset(uint bit)
{
if constexpr (std::is_integral<type>::value)
if constexpr (std::is_integral_v<type>)
{
return atomic_storage<type>::btr(m_data, bit & (sizeof(T) * 8 - 1));
}
@ -1668,7 +1668,7 @@ public:
bool bit_test_invert(uint bit)
{
if constexpr (std::is_integral<type>::value)
if constexpr (std::is_integral_v<type>)
{
return atomic_storage<type>::btc(m_data, bit & (sizeof(T) * 8 - 1));
}

6
rpcs3/util/endian.hpp
View File

@ -154,9 +154,9 @@ namespace stx
stype m_data;
static_assert(!std::is_pointer<type>::value, "se_t<> error: invalid type (pointer)");
static_assert(!std::is_reference<type>::value, "se_t<> error: invalid type (reference)");
static_assert(!std::is_array<type>::value, "se_t<> error: invalid type (array)");
static_assert(!std::is_pointer_v<type>, "se_t<> error: invalid type (pointer)");
static_assert(!std::is_reference_v<type>, "se_t<> error: invalid type (reference)");
static_assert(!std::is_array_v<type>, "se_t<> error: invalid type (array)");
static_assert(sizeof(type) == alignof(type), "se_t<> error: unexpected alignment");
static constexpr stype to_data(type value) noexcept

2
rpcs3/util/fnv_hash.hpp
View File

@ -14,7 +14,7 @@ namespace rpcs3
return static_cast<usz>(value);
}
template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
static inline usz hash64(usz hash_value, T data)
{
hash_value ^= data;

6
rpcs3/util/to_endian.hpp
View File

@ -16,7 +16,7 @@ struct to_se
};
template <typename T2>
struct to_se_<T2, std::enable_if_t<std::is_arithmetic<T2>::value || std::is_enum<T2>::value>>
struct to_se_<T2, std::enable_if_t<std::is_arithmetic_v<T2> || std::is_enum_v<T2>>>
{
using type = std::conditional_t<(sizeof(T2) > 1), se_t<T2, Se>, T2>;
};
@ -44,14 +44,14 @@ struct to_se<s128, Se>
};
template <typename T, bool Se>
struct to_se<const T, Se, std::enable_if_t<!std::is_array<T>::value>>
struct to_se<const T, Se, std::enable_if_t<!std::is_array_v<T>>>
{
// Move const qualifier
using type = const typename to_se<T, Se>::type;
};
template <typename T, bool Se>
struct to_se<volatile T, Se, std::enable_if_t<!std::is_array<T>::value && !std::is_const<T>::value>>
struct to_se<volatile T, Se, std::enable_if_t<!std::is_array_v<T> && !std::is_const_v<T>>>
{
// Move volatile qualifier
using type = volatile typename to_se<T, Se>::type;

14
rpcs3/util/types.hpp
View File

@ -752,7 +752,7 @@ inline u32 offset32(T T2::*const mptr)
template <typename T>
struct offset32_array
{
static_assert(std::is_array<T>::value, "Invalid pointer-to-member type (array expected)");
static_assert(std::is_array_v<T>, "Invalid pointer-to-member type (array expected)");
template <typename Arg>
static inline u32 index32(const Arg& arg)
@ -956,7 +956,7 @@ template <typename From, typename To = void, typename = void>
struct narrow_impl
{
// Temporarily (diagnostic)
static_assert(std::is_void<To>::value, "narrow_impl<> specialization not found");
static_assert(std::is_void_v<To>, "narrow_impl<> specialization not found");
// Returns true if value cannot be represented in type To
static constexpr bool test(const From&)
@ -968,7 +968,7 @@ struct narrow_impl
// Unsigned to unsigned narrowing
template <typename From, typename To>
struct narrow_impl<From, To, std::enable_if_t<std::is_unsigned<From>::value && std::is_unsigned<To>::value>>
struct narrow_impl<From, To, std::enable_if_t<std::is_unsigned_v<From> && std::is_unsigned_v<To>>>
{
static constexpr bool test(const From& value)
{
@ -978,7 +978,7 @@ struct narrow_impl<From, To, std::enable_if_t<std::is_unsigned<From>::value && s
// Signed to signed narrowing
template <typename From, typename To>
struct narrow_impl<From, To, std::enable_if_t<std::is_signed<From>::value && std::is_signed<To>::value>>
struct narrow_impl<From, To, std::enable_if_t<std::is_signed_v<From> && std::is_signed_v<To>>>
{
static constexpr bool test(const From& value)
{
@ -988,7 +988,7 @@ struct narrow_impl<From, To, std::enable_if_t<std::is_signed<From>::value && std
// Unsigned to signed narrowing
template <typename From, typename To>
struct narrow_impl<From, To, std::enable_if_t<std::is_unsigned<From>::value && std::is_signed<To>::value>>
struct narrow_impl<From, To, std::enable_if_t<std::is_unsigned_v<From> && std::is_signed_v<To>>>
{
static constexpr bool test(const From& value)
{
@ -998,7 +998,7 @@ struct narrow_impl<From, To, std::enable_if_t<std::is_unsigned<From>::value && s
// Signed to unsigned narrowing (I)
template <typename From, typename To>
struct narrow_impl<From, To, std::enable_if_t<std::is_signed<From>::value && std::is_unsigned<To>::value && sizeof(To) >= sizeof(From)>>
struct narrow_impl<From, To, std::enable_if_t<std::is_signed_v<From> && std::is_unsigned_v<To> && sizeof(To) >= sizeof(From)>>
{
static constexpr bool test(const From& value)
{
@ -1008,7 +1008,7 @@ struct narrow_impl<From, To, std::enable_if_t<std::is_signed<From>::value && std
// Signed to unsigned narrowing (II)
template <typename From, typename To>
struct narrow_impl<From, To, std::enable_if_t<std::is_signed<From>::value && std::is_unsigned<To>::value && sizeof(To) < sizeof(From)>>
struct narrow_impl<From, To, std::enable_if_t<std::is_signed_v<From> && std::is_unsigned_v<To> && sizeof(To) < sizeof(From)>>
{
static constexpr bool test(const From& value)
{