games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-20 20:23:03 +02:00
Code Issues Releases Activity

Fix SonarCloud issues

Browse Source 
Replace the use of "::value" with "std::is_abstract_v" and similar issues
This commit is contained in:
Alexander Wilms 2024-03-02 12:48:17 +01:00
parent 00058ea609
commit ea48257100
8 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/int3.h
View File

@ -194,7 +194,7 @@ public:
template<typename Container> template<typename Container>
int3 findClosestTile (Container & container, int3 dest) int3 findClosestTile (Container & container, int3 dest)
{ {
static_assert(std::is_same<typename Container::value_type, int3>::value, static_assert(std::is_same_v<typename Container::value_type, int3>,
"findClosestTile requires <int3> container."); "findClosestTile requires <int3> container.");
int3 result(-1, -1, -1); int3 result(-1, -1, -1);

30
lib/serializer/BinaryDeserializer.h
View File

@ -96,7 +96,7 @@ class DLL_LINKAGE BinaryDeserializer : public CLoaderBase
{ {
static T *invoke(IGameCallback *cb) static T *invoke(IGameCallback *cb)
{ {
static_assert(!std::is_abstract<T>::value, "Cannot call new upon abstract classes!"); static_assert(!std::is_abstract_v<T>, "Cannot call new upon abstract classes!");
return new T(cb); return new T(cb);
} }
}; };
@ -171,21 +171,21 @@ public:
return * this; return * this;
} }
template < class T, typename std::enable_if < std::is_fundamental<T>::value && !std::is_same<T, bool>::value, int >::type = 0 > template < class T, typename std::enable_if_t < std::is_fundamental_v<T> && !std::is_same_v<T, bool>, int > = 0 >
void load(T &data) void load(T &data)
{ {
this->read(static_cast<void *>(&data), sizeof(data), reverseEndianess); this->read(static_cast<void *>(&data), sizeof(data), reverseEndianess);
} }
template < typename T, typename std::enable_if < is_serializeable<BinaryDeserializer, T>::value, int >::type = 0 > template < typename T, typename std::enable_if_t < is_serializeable<BinaryDeserializer, T>::value, int > = 0 >
void load(T &data) void load(T &data)
{ {
////that const cast is evil because it allows to implicitly overwrite const objects when deserializing ////that const cast is evil because it allows to implicitly overwrite const objects when deserializing
typedef typename std::remove_const<T>::type nonConstT; typedef typename std::remove_const_t<T> nonConstT;
auto & hlp = const_cast<nonConstT &>(data); auto & hlp = const_cast<nonConstT &>(data);
hlp.serialize(*this); hlp.serialize(*this);
} }
template < typename T, typename std::enable_if < std::is_array<T>::value, int >::type = 0 > template < typename T, typename std::enable_if_t < std::is_array_v<T>, int > = 0 >
void load(T &data) void load(T &data)
{ {
ui32 size = std::size(data); ui32 size = std::size(data);
@ -193,7 +193,7 @@ public:
load(data[i]); load(data[i]);
} }
template < typename T, typename std::enable_if < std::is_enum<T>::value, int >::type = 0 > template < typename T, typename std::enable_if_t < std::is_enum_v<T>, int > = 0 >
void load(T &data) void load(T &data)
{ {
si32 read; si32 read;
@ -201,7 +201,7 @@ public:
data = static_cast<T>(read); data = static_cast<T>(read);
} }
template < typename T, typename std::enable_if < std::is_same<T, bool>::value, int >::type = 0 > template < typename T, typename std::enable_if_t < std::is_same_v<T, bool>, int > = 0 >
void load(T &data) void load(T &data)
{ {
ui8 read; ui8 read;
@ -209,7 +209,7 @@ public:
data = static_cast<bool>(read); data = static_cast<bool>(read);
} }
template <typename T, typename std::enable_if < !std::is_same<T, bool >::value, int >::type = 0> template <typename T, typename std::enable_if_t < !std::is_same_v<T, bool >, int > = 0>
void load(std::vector<T> &data) void load(std::vector<T> &data)
{ {
ui32 length = readAndCheckLength(); ui32 length = readAndCheckLength();
@ -218,7 +218,7 @@ public:
load( data[i]); load( data[i]);
} }
template < typename T, typename std::enable_if < std::is_pointer<T>::value, int >::type = 0 > template < typename T, typename std::enable_if_t < std::is_pointer_v<T>, int > = 0 >
void load(T &data) void load(T &data)
{ {
bool isNull; bool isNull;
@ -232,7 +232,7 @@ public:
loadPointerImpl(data); loadPointerImpl(data);
} }
template < typename T, typename std::enable_if < std::is_base_of_v<Entity, std::remove_pointer_t<T>>, int >::type = 0 > template < typename T, typename std::enable_if_t < std::is_base_of_v<Entity, std::remove_pointer_t<T>>, int > = 0 >
void loadPointerImpl(T &data) void loadPointerImpl(T &data)
{ {
using DataType = std::remove_pointer_t<T>; using DataType = std::remove_pointer_t<T>;
@ -245,12 +245,12 @@ public:
data = const_cast<DataType *>(constData); data = const_cast<DataType *>(constData);
} }
template < typename T, typename std::enable_if < !std::is_base_of_v<Entity, std::remove_pointer_t<T>>, int >::type = 0 > template < typename T, typename std::enable_if_t < !std::is_base_of_v<Entity, std::remove_pointer_t<T>>, int > = 0 >
void loadPointerImpl(T &data) void loadPointerImpl(T &data)
{ {
if(reader->smartVectorMembersSerialization) if(reader->smartVectorMembersSerialization)
{ {
typedef typename std::remove_const<typename std::remove_pointer<T>::type>::type TObjectType; //eg: const CGHeroInstance * => CGHeroInstance typedef typename std::remove_const_t<typename std::remove_pointer_t<T>> TObjectType; //eg: const CGHeroInstance * => CGHeroInstance
typedef typename VectorizedTypeFor<TObjectType>::type VType; //eg: CGHeroInstance -> CGobjectInstance typedef typename VectorizedTypeFor<TObjectType>::type VType; //eg: CGHeroInstance -> CGobjectInstance
typedef typename VectorizedIDType<TObjectType>::type IDType; typedef typename VectorizedIDType<TObjectType>::type IDType;
if(const auto *info = reader->getVectorizedTypeInfo<VType, IDType>()) if(const auto *info = reader->getVectorizedTypeInfo<VType, IDType>())
@ -292,8 +292,8 @@ public:
if(!tid) if(!tid)
{ {
typedef typename std::remove_pointer<T>::type npT; typedef typename std::remove_pointer_t<T> npT;
typedef typename std::remove_const<npT>::type ncpT; typedef typename std::remove_const_t<npT> ncpT;
data = ClassObjectCreator<ncpT>::invoke(cb); data = ClassObjectCreator<ncpT>::invoke(cb);
ptrAllocated(data, pid); ptrAllocated(data, pid);
load(*data); load(*data);
@ -326,7 +326,7 @@ public:
template <typename T> template <typename T>
void load(std::shared_ptr<T> &data) void load(std::shared_ptr<T> &data)
{ {
typedef typename std::remove_const<T>::type NonConstT; typedef typename std::remove_const_t<T> NonConstT;
NonConstT *internalPtr; NonConstT *internalPtr;
load(internalPtr); load(internalPtr);

20
lib/serializer/BinarySerializer.h
View File

@ -134,28 +134,28 @@ public:
return * this; return * this;
} }
template < typename T, typename std::enable_if < std::is_same<T, bool>::value, int >::type = 0 > template < typename T, typename std::enable_if_t < std::is_same_v<T, bool>, int > = 0 >
void save(const T &data) void save(const T &data)
{ {
ui8 writ = static_cast<ui8>(data); ui8 writ = static_cast<ui8>(data);
save(writ); save(writ);
} }
template < class T, typename std::enable_if < std::is_fundamental<T>::value && !std::is_same<T, bool>::value, int >::type = 0 > template < class T, typename std::enable_if_t < std::is_fundamental_v<T> && !std::is_same_v<T, bool>, int > = 0 >
void save(const T &data) void save(const T &data)
{ {
// save primitive - simply dump binary data to output // save primitive - simply dump binary data to output
this->write(static_cast<const void *>(&data), sizeof(data)); this->write(static_cast<const void *>(&data), sizeof(data));
} }
template < typename T, typename std::enable_if < std::is_enum<T>::value, int >::type = 0 > template < typename T, typename std::enable_if_t < std::is_enum_v<T>, int > = 0 >
void save(const T &data) void save(const T &data)
{ {
si32 writ = static_cast<si32>(data); si32 writ = static_cast<si32>(data);
*this & writ; *this & writ;
} }
template < typename T, typename std::enable_if < std::is_array<T>::value, int >::type = 0 > template < typename T, typename std::enable_if_t < std::is_array_v<T>, int > = 0 >
void save(const T &data) void save(const T &data)
{ {
ui32 size = std::size(data); ui32 size = std::size(data);
@ -163,7 +163,7 @@ public:
*this & data[i]; *this & data[i];
} }
template < typename T, typename std::enable_if < std::is_pointer<T>::value, int >::type = 0 > template < typename T, typename std::enable_if_t < std::is_pointer_v<T>, int > = 0 >
void save(const T &data) void save(const T &data)
{ {
//write if pointer is not nullptr //write if pointer is not nullptr
@ -177,17 +177,17 @@ public:
savePointerImpl(data); savePointerImpl(data);
} }
template < typename T, typename std::enable_if < std::is_base_of_v<Entity, std::remove_pointer_t<T>>, int >::type = 0 > template < typename T, typename std::enable_if_t < std::is_base_of_v<Entity, std::remove_pointer_t<T>>, int > = 0 >
void savePointerImpl(const T &data) void savePointerImpl(const T &data)
{ {
auto index = data->getId(); auto index = data->getId();
save(index); save(index);
} }
template < typename T, typename std::enable_if < !std::is_base_of_v<Entity, std::remove_pointer_t<T>>, int >::type = 0 > template < typename T, typename std::enable_if_t < !std::is_base_of_v<Entity, std::remove_pointer_t<T>>, int > = 0 >
void savePointerImpl(const T &data) void savePointerImpl(const T &data)
{ {
typedef typename std::remove_const<typename std::remove_pointer<T>::type>::type TObjectType; typedef typename std::remove_const_t<typename std::remove_pointer_t<T>> TObjectType;
if(writer->smartVectorMembersSerialization) if(writer->smartVectorMembersSerialization)
{ {
@ -239,7 +239,7 @@ public:
applier.getApplier(tid)->savePtr(*this, static_cast<const void*>(data)); //call serializer specific for our real type applier.getApplier(tid)->savePtr(*this, static_cast<const void*>(data)); //call serializer specific for our real type
} }
template < typename T, typename std::enable_if < is_serializeable<BinarySerializer, T>::value, int >::type = 0 > template < typename T, typename std::enable_if_t < is_serializeable<BinarySerializer, T>::value, int > = 0 >
void save(const T &data) void save(const T &data)
{ {
const_cast<T&>(data).serialize(*this); const_cast<T&>(data).serialize(*this);
@ -268,7 +268,7 @@ public:
T *internalPtr = data.get(); T *internalPtr = data.get();
save(internalPtr); save(internalPtr);
} }
template <typename T, typename std::enable_if < !std::is_same<T, bool >::value, int >::type = 0> template <typename T, typename std::enable_if_t < !std::is_same_v<T, bool >, int > = 0>
void save(const std::vector<T> &data) void save(const std::vector<T> &data)
{ {
ui32 length = (ui32)data.size(); ui32 length = (ui32)data.size();

2
lib/serializer/CSerializer.h
View File

@ -138,7 +138,7 @@ struct is_serializeable
template<class U> template<class U>
static Yes test(U * data, S* arg1 = nullptr, typename std::enable_if_t<std::is_void_v<decltype(data->serialize(*arg1))>> * = nullptr); static Yes test(U * data, S* arg1 = nullptr, typename std::enable_if_t<std::is_void_v<decltype(data->serialize(*arg1))>> * = nullptr);
static No test(...); static No test(...);
static const bool value = sizeof(Yes) == sizeof(is_serializeable::test((typename std::remove_reference<typename std::remove_cv<T>::type>::type*)nullptr)); static const bool value = sizeof(Yes) == sizeof(is_serializeable::test((typename std::remove_reference_t<typename std::remove_cv_t<T>>*)nullptr));
}; };
template <typename T> //metafunction returning CGObjectInstance if T is its derivate or T elsewise template <typename T> //metafunction returning CGObjectInstance if T is its derivate or T elsewise

4
mapeditor/StdInc.h
View File

@ -15,8 +15,8 @@
VCMI_LIB_USING_NAMESPACE VCMI_LIB_USING_NAMESPACE
using NumericPointer = typename std::conditional<sizeof(void *) == sizeof(unsigned long long), using NumericPointer = typename std::conditional_t<sizeof(void *) == sizeof(unsigned long long),
unsigned long long, unsigned int>::type; unsigned long long, unsigned int>;
template<class Type> template<class Type>
NumericPointer data_cast(Type * _pointer) NumericPointer data_cast(Type * _pointer)

34
scripting/lua/LuaStack.h
View File

@ -26,13 +26,13 @@ namespace detail
template<typename T> template<typename T>
struct IsRegularClass struct IsRegularClass
{ {
static constexpr auto value = std::is_class<T>::value && !std::is_base_of<IdentifierBase, T>::value; static constexpr auto value = std::is_class_v<T> && !std::is_base_of_v<IdentifierBase, T>;
}; };
template<typename T> template<typename T>
struct IsIdClass struct IsIdClass
{ {
static constexpr auto value = std::is_class<T>::value && std::is_base_of<IdentifierBase, T>::value; static constexpr auto value = std::is_class_v<T> && std::is_base_of_v<IdentifierBase, T>;
}; };
} }
@ -61,13 +61,13 @@ public:
pushNil(); pushNil();
} }
template<typename T, typename std::enable_if< std::is_integral<T>::value && !std::is_same<T, bool>::value, int>::type = 0> template<typename T, typename std::enable_if_t< std::is_integral_v<T> && !std::is_same_v<T, bool>, int> = 0>
void push(const T value) void push(const T value)
{ {
pushInteger(static_cast<lua_Integer>(value)); pushInteger(static_cast<lua_Integer>(value));
} }
template<typename T, typename std::enable_if< std::is_enum<T>::value, int>::type = 0> template<typename T, typename std::enable_if_t< std::is_enum_v<T>, int> = 0>
void push(const T value) void push(const T value)
{ {
pushInteger(static_cast<lua_Integer>(value)); pushInteger(static_cast<lua_Integer>(value));
@ -75,13 +75,13 @@ public:
void push(const int3 & value); void push(const int3 & value);
template<typename T, typename std::enable_if< detail::IsIdClass<T>::value, int>::type = 0> template<typename T, typename std::enable_if_t< detail::IsIdClass<T>::value, int> = 0>
void push(const T & value) void push(const T & value)
{ {
pushInteger(static_cast<lua_Integer>(value.getNum())); pushInteger(static_cast<lua_Integer>(value.getNum()));
} }
template<typename T, typename std::enable_if<detail::IsRegularClass<T>::value, int>::type = 0> template<typename T, typename std::enable_if_t<detail::IsRegularClass<T>::value, int> = 0>
void push(T * value) void push(T * value)
{ {
using UData = T *; using UData = T *;
@ -107,7 +107,7 @@ public:
lua_setmetatable(L, -2); lua_setmetatable(L, -2);
} }
template<typename T, typename std::enable_if<detail::IsRegularClass<T>::value, int>::type = 0> template<typename T, typename std::enable_if_t<detail::IsRegularClass<T>::value, int> = 0>
void push(std::shared_ptr<T> value) void push(std::shared_ptr<T> value)
{ {
using UData = std::shared_ptr<T>; using UData = std::shared_ptr<T>;
@ -133,7 +133,7 @@ public:
lua_setmetatable(L, -2); lua_setmetatable(L, -2);
} }
template<typename T, typename std::enable_if<detail::IsRegularClass<T>::value, int>::type = 0> template<typename T, typename std::enable_if_t<detail::IsRegularClass<T>::value, int> = 0>
void push(std::unique_ptr<T> && value) void push(std::unique_ptr<T> && value)
{ {
using UData = std::unique_ptr<T>; using UData = std::unique_ptr<T>;
@ -163,7 +163,7 @@ public:
bool tryGet(int position, bool & value); bool tryGet(int position, bool & value);
template<typename T, typename std::enable_if< std::is_integral<T>::value && !std::is_same<T, bool>::value, int>::type = 0> template<typename T, typename std::enable_if_t< std::is_integral_v<T> && !std::is_same_v<T, bool>, int> = 0>
bool tryGet(int position, T & value) bool tryGet(int position, T & value)
{ {
lua_Integer temp; lua_Integer temp;
@ -178,7 +178,7 @@ public:
} }
} }
template<typename T, typename std::enable_if<detail::IsIdClass<T>::value, int>::type = 0> template<typename T, typename std::enable_if_t<detail::IsIdClass<T>::value, int> = 0>
bool tryGet(int position, T & value) bool tryGet(int position, T & value)
{ {
lua_Integer temp; lua_Integer temp;
@ -193,7 +193,7 @@ public:
} }
} }
template<typename T, typename std::enable_if< std::is_enum<T>::value, int>::type = 0> template<typename T, typename std::enable_if_t< std::is_enum_v<T>, int> = 0>
bool tryGet(int position, T & value) bool tryGet(int position, T & value)
{ {
lua_Integer temp; lua_Integer temp;
@ -213,10 +213,10 @@ public:
bool tryGet(int position, double & value); bool tryGet(int position, double & value);
bool tryGet(int position, std::string & value); bool tryGet(int position, std::string & value);
template<typename T, typename std::enable_if<detail::IsRegularClass<T>::value && std::is_const<T>::value, int>::type = 0> template<typename T, typename std::enable_if_t<detail::IsRegularClass<T>::value && std::is_const_v<T>, int> = 0>
STRONG_INLINE bool tryGet(int position, T * & value) STRONG_INLINE bool tryGet(int position, T * & value)
{ {
using NCValue = typename std::remove_const<T>::type; using NCValue = typename std::remove_const_t<T>;
using UData = NCValue *; using UData = NCValue *;
using CUData = T *; using CUData = T *;
@ -224,16 +224,16 @@ public:
return tryGetCUData<T *, UData, CUData>(position, value); return tryGetCUData<T *, UData, CUData>(position, value);
} }
template<typename T, typename std::enable_if<detail::IsRegularClass<T>::value && !std::is_const<T>::value, int>::type = 0> template<typename T, typename std::enable_if_t<detail::IsRegularClass<T>::value && !std::is_const_v<T>, int> = 0>
STRONG_INLINE bool tryGet(int position, T * & value) STRONG_INLINE bool tryGet(int position, T * & value)
{ {
return tryGetUData<T *>(position, value); return tryGetUData<T *>(position, value);
} }
template<typename T, typename std::enable_if<detail::IsRegularClass<T>::value && std::is_const<T>::value, int>::type = 0> template<typename T, typename std::enable_if_t<detail::IsRegularClass<T>::value && std::is_const_v<T>, int> = 0>
STRONG_INLINE bool tryGet(int position, std::shared_ptr<T> & value) STRONG_INLINE bool tryGet(int position, std::shared_ptr<T> & value)
{ {
using NCValue = typename std::remove_const<T>::type; using NCValue = typename std::remove_const_t<T>;
using UData = std::shared_ptr<NCValue>; using UData = std::shared_ptr<NCValue>;
using CUData = std::shared_ptr<T>; using CUData = std::shared_ptr<T>;
@ -241,7 +241,7 @@ public:
return tryGetCUData<std::shared_ptr<T>, UData, CUData>(position, value); return tryGetCUData<std::shared_ptr<T>, UData, CUData>(position, value);
} }
template<typename T, typename std::enable_if<detail::IsRegularClass<T>::value && !std::is_const<T>::value, int>::type = 0> template<typename T, typename std::enable_if_t<detail::IsRegularClass<T>::value && !std::is_const_v<T>, int> = 0>
STRONG_INLINE bool tryGet(int position, std::shared_ptr<T> & value) STRONG_INLINE bool tryGet(int position, std::shared_ptr<T> & value)
{ {
return tryGetUData<std::shared_ptr<T>>(position, value); return tryGetUData<std::shared_ptr<T>>(position, value);

6
scripting/lua/LuaWrapper.h
View File

@ -124,7 +124,7 @@ template<class T, class Proxy = T>
class OpaqueWrapper : public RegistarBase class OpaqueWrapper : public RegistarBase
{ {
public: public:
using ObjectType = typename std::remove_cv<T>::type; using ObjectType = typename std::remove_cv_t<T>;
using UDataType = ObjectType *; using UDataType = ObjectType *;
using CUDataType = const ObjectType *; using CUDataType = const ObjectType *;
@ -163,7 +163,7 @@ template<class T, class Proxy = T>
class SharedWrapper : public RegistarBase class SharedWrapper : public RegistarBase
{ {
public: public:
using ObjectType = typename std::remove_cv<T>::type; using ObjectType = typename std::remove_cv_t<T>;
using UDataType = std::shared_ptr<T>; using UDataType = std::shared_ptr<T>;
using CustomRegType = detail::CustomRegType; using CustomRegType = detail::CustomRegType;
@ -208,7 +208,7 @@ template<class T, class Proxy = T>
class UniqueOpaqueWrapper : public api::Registar class UniqueOpaqueWrapper : public api::Registar
{ {
public: public:
using ObjectType = typename std::remove_cv<T>::type; using ObjectType = typename std::remove_cv_t<T>;
using UDataType = std::unique_ptr<T>; using UDataType = std::unique_ptr<T>;
using CustomRegType = detail::CustomRegType; using CustomRegType = detail::CustomRegType;

2
scripting/lua/api/events/SubscriptionRegistryProxy.h
View File

@ -42,7 +42,7 @@ public:
using EventType = typename EventProxy::ObjectType; using EventType = typename EventProxy::ObjectType;
using RegistryType = ::events::SubscriptionRegistry<EventType>; using RegistryType = ::events::SubscriptionRegistry<EventType>;
static_assert(std::is_base_of<::events::Event, EventType>::value, "Invalid template parameter"); static_assert(std::is_base_of_v<::events::Event, EventType>, "Invalid template parameter");
static int subscribeBefore(lua_State * L) static int subscribeBefore(lua_State * L)
{ {