Use concepts to check ESM record types

This commit is contained in:
elsid
2026-07-12 16:24:22 +02:00
parent c0511c1aee
commit 08843ea6c9
8 changed files with 81 additions and 203 deletions
+14 -14
View File
@@ -146,33 +146,33 @@ namespace EsmTool
return;
std::cout << "\n Record: " << ESM::NAME(reader.hdr().record.typeId).toStringView();
if constexpr (ESM::hasId<T>)
if constexpr (ESM::HasId<T>)
std::cout << "\n Id: " << value.mId;
if constexpr (ESM4::hasFlags<T>)
if constexpr (ESM4::HasFlags<T>)
std::cout << "\n Record flags: " << recordFlags(value.mFlags);
if constexpr (ESM4::hasParent<T>)
if constexpr (ESM4::HasParent<T>)
std::cout << "\n Parent: " << value.mParent;
if constexpr (ESM4::hasEditorId<T>)
if constexpr (ESM4::HasEditorId<T>)
std::cout << "\n EditorId: " << value.mEditorId;
if constexpr (ESM4::hasFullName<T>)
if constexpr (ESM4::HasFullName<T>)
std::cout << "\n FullName: " << value.mFullName;
if constexpr (ESM4::hasCellFlags<T>)
if constexpr (ESM4::HasCellFlags<T>)
std::cout << "\n CellFlags: " << WriteCellFlags{ value.mCellFlags };
if constexpr (ESM4::hasX<T>)
if constexpr (ESM4::HasX<T>)
std::cout << "\n X: " << value.mX;
if constexpr (ESM4::hasY<T>)
if constexpr (ESM4::HasY<T>)
std::cout << "\n Y: " << value.mY;
if constexpr (ESM::hasModel<T>)
if constexpr (ESM::HasModel<T>)
std::cout << "\n Model: " << value.mModel.getOriginal();
if constexpr (ESM4::hasNif<T>)
if constexpr (ESM4::HasNif<T>)
std::cout << "\n Nif:" << WriteArray("\n - ", value.mNif);
if constexpr (ESM4::hasKf<T>)
if constexpr (ESM4::HasKf<T>)
std::cout << "\n Kf:" << WriteArray("\n - ", value.mKf);
if constexpr (ESM4::hasType<T>)
if constexpr (ESM4::HasType<T>)
std::cout << "\n Type: " << value.mType;
if constexpr (ESM4::hasValue<T>)
if constexpr (ESM4::HasValue<T>)
std::cout << "\n Value: " << value.mValue;
if constexpr (ESM4::hasData<T>)
if constexpr (ESM4::HasData<T>)
std::cout << "\n Data: " << WriteData(value.mData);
std::cout << '\n';
}
+1 -1
View File
@@ -268,7 +268,7 @@ namespace MWWorld
auto recordType = static_cast<ESM4::RecordTypes>(reader.hdr().record.typeId);
ESM::RecNameInts esm4RecName = static_cast<ESM::RecNameInts>(ESM::esm4Recname(recordType));
if constexpr (HasRecordId<T>::value)
if constexpr (HasRecordId<T>)
{
if constexpr (ESM::isESM4Rec(T::sRecordId))
{
+2 -6
View File
@@ -309,14 +309,10 @@ namespace MWWorld
template <>
const ESM::NPC* ESMStore::insert<ESM::NPC>(const ESM::NPC& npc);
template <class T, class = std::void_t<>>
struct HasRecordId : std::false_type
{
};
template <class T>
struct HasRecordId<T, std::void_t<decltype(T::sRecordId)>> : std::true_type
concept HasRecordId = requires
{
T::sRecordId;
};
}
+23 -13
View File
@@ -346,7 +346,7 @@ TYPED_TEST_P(StoreTest, delete_test)
template <typename T>
static unsigned int hasSameRecordId(const MWWorld::Store<T>& store, ESM::RecNameInts recName)
{
if constexpr (MWWorld::HasRecordId<T>::value)
if constexpr (MWWorld::HasRecordId<T>)
{
return T::sRecordId == recName ? 1 : 0;
}
@@ -359,7 +359,7 @@ static unsigned int hasSameRecordId(const MWWorld::Store<T>& store, ESM::RecName
template <typename T>
static void testRecNameIntCount(const MWWorld::Store<T>& store, const MWWorld::ESMStore::StoreTuple& stores)
{
if constexpr (MWWorld::HasRecordId<T>::value)
if constexpr (MWWorld::HasRecordId<T>)
{
const unsigned int recordIdCount
= std::apply([](auto&&... x) { return (hasSameRecordId(x, T::sRecordId) + ...); }, stores);
@@ -441,7 +441,7 @@ namespace
const int index = 3;
const std::string stringId = "foobar";
decltype(RecordType::mId) refId;
if constexpr (ESM::hasIndex<RecordType> && !std::is_same_v<RecordType, ESM::LandTexture>)
if constexpr (ESM::HasIndex<RecordType> && !std::is_same_v<RecordType, ESM::LandTexture>)
refId = RecordType::indexToRefId(index);
else if constexpr (std::is_same_v<RecordType, ESM::Cell>)
{
@@ -467,10 +467,10 @@ namespace
record.mId = refId;
if constexpr (ESM::hasStringId<RecordType>)
if constexpr (ESM::HasStringId<RecordType>)
record.mStringId = stringId;
if constexpr (ESM::hasIndex<RecordType>)
if constexpr (ESM::HasIndex<RecordType>)
record.mIndex = index;
if constexpr (std::is_same_v<RecordType, ESM::Global>)
@@ -497,7 +497,7 @@ namespace
ASSERT_NE(texture, nullptr);
return;
}
else if constexpr (ESM::hasIndex<RecordType>)
else if constexpr (ESM::HasIndex<RecordType>)
result = esmStore.get<RecordType>().search(index);
else
result = esmStore.get<RecordType>().search(refId);
@@ -507,16 +507,26 @@ namespace
}
}
static_assert(ESM::hasStringId<ESM::Dialogue>);
static_assert(ESM::HasStringId<ESM::Dialogue>);
template <class T, class = std::void_t<>>
struct HasSaveFunction : std::false_type
template <class T>
concept CanSave = requires(T& record, ESM::ESMWriter& writer)
{
record.save(writer, bool());
};
template <class T>
struct HasSaveFunction : std::bool_constant<CanSave<T>>
{
};
template <class T>
struct HasSaveFunction<T, std::void_t<decltype(std::declval<T>().save(std::declval<ESM::ESMWriter&>(), bool()))>>
: std::true_type
struct HasId : std::bool_constant<ESM::HasId<T>>
{
};
template <class T>
struct HasModel : std::bool_constant<ESM::HasModel<T>>
{
};
@@ -573,9 +583,9 @@ namespace
};
using RecordTypes = typename ToRecordTypes<MWWorld::ESMStore::StoreTuple>::Type;
using RecordTypesWithId = typename FilterTypes<ESM::HasId, RecordTypes>::Type;
using RecordTypesWithId = typename FilterTypes<HasId, RecordTypes>::Type;
using RecordTypesWithSave = typename FilterTypes<HasSaveFunction, RecordTypesWithId>::Type;
using RecordTypesWithModel = typename FilterTypes<ESM::HasModel, RecordTypesWithSave>::Type;
using RecordTypesWithModel = typename FilterTypes<HasModel, RecordTypesWithSave>::Type;
REGISTER_TYPED_TEST_SUITE_P(StoreSaveLoadTest, shouldNotChangeRefId);
+5 -21
View File
@@ -1,35 +1,19 @@
#ifndef OPENMW_COMPONENTS_ESM_TYPETRAITS
#define OPENMW_COMPONENTS_ESM_TYPETRAITS
#include <type_traits>
namespace ESM
{
template <class T, class = std::void_t<>>
struct HasId : std::false_type
template <class T>
concept HasId = requires
{
T::mId;
};
template <class T>
struct HasId<T, std::void_t<decltype(T::mId)>> : std::true_type
concept HasModel = requires
{
T::mModel;
};
template <class T>
inline constexpr bool hasId = HasId<T>::value;
template <class T, class = std::void_t<>>
struct HasModel : std::false_type
{
};
template <class T>
struct HasModel<T, std::void_t<decltype(T::mModel)>> : std::true_type
{
};
template <class T>
inline constexpr bool hasModel = HasModel<T>::value;
}
#endif // OPENMW_COMPONENTS_ESM_TYPETRAITS
+5 -21
View File
@@ -1,35 +1,19 @@
#ifndef OPENMW_COMPONENTS_ESM3_TYPETRAITS
#define OPENMW_COMPONENTS_ESM3_TYPETRAITS
#include <type_traits>
namespace ESM
{
template <class T, class = std::void_t<>>
struct HasIndex : std::false_type
template <class T>
concept HasIndex = requires
{
T::mIndex;
};
template <class T>
struct HasIndex<T, std::void_t<decltype(T::mIndex)>> : std::true_type
concept HasStringId = requires
{
T::mStringId;
};
template <class T>
inline constexpr bool hasIndex = HasIndex<T>::value;
template <class T, class = std::void_t<>>
struct HasStringId : std::false_type
{
};
template <class T>
struct HasStringId<T, std::void_t<decltype(T::mStringId)>> : std::true_type
{
};
template <class T>
inline constexpr bool hasStringId = HasStringId<T>::value;
}
#endif // OPENMW_COMPONENTS_ESM3_TYPETRAITS
+25 -111
View File
@@ -1,165 +1,79 @@
#ifndef OPENMW_COMPONENTS_ESM4_TYPETRAITS
#define OPENMW_COMPONENTS_ESM4_TYPETRAITS
#include <type_traits>
namespace ESM4
{
template <class T, class = std::void_t<>>
struct HasParent : std::false_type
template <class T>
concept HasParent = requires
{
T::mParent;
};
template <class T>
struct HasParent<T, std::void_t<decltype(T::mParent)>> : std::true_type
concept HasFlags = requires
{
T::mFlags;
};
template <class T>
inline constexpr bool hasParent = HasParent<T>::value;
template <class T, class = std::void_t<>>
struct HasFlags : std::false_type
concept HasEditorId = requires
{
T::mEditorId;
};
template <class T>
struct HasFlags<T, std::void_t<decltype(T::mFlags)>> : std::true_type
concept HasFullName = requires
{
T::mFullName;
};
template <class T>
inline constexpr bool hasFlags = HasFlags<T>::value;
template <class T, class = std::void_t<>>
struct HasEditorId : std::false_type
concept HasCellFlags = requires
{
T::mCellFlags;
};
template <class T>
struct HasEditorId<T, std::void_t<decltype(T::mEditorId)>> : std::true_type
concept HasX = requires
{
T::mX;
};
template <class T>
inline constexpr bool hasEditorId = HasEditorId<T>::value;
template <class T, class = std::void_t<>>
struct HasFullName : std::false_type
concept HasY = requires
{
T::mY;
};
template <class T>
struct HasFullName<T, std::void_t<decltype(T::mFullName)>> : std::true_type
concept HasNif = requires
{
T::mNif;
};
template <class T>
inline constexpr bool hasFullName = HasFullName<T>::value;
template <class T, class = std::void_t<>>
struct HasCellFlags : std::false_type
concept HasKf = requires
{
T::mKf;
};
template <class T>
struct HasCellFlags<T, std::void_t<decltype(T::mCellFlags)>> : std::true_type
concept HasType = requires
{
T::mType;
};
template <class T>
inline constexpr bool hasCellFlags = HasCellFlags<T>::value;
template <class T, class = std::void_t<>>
struct HasX : std::false_type
concept HasValue = requires
{
T::mValue;
};
template <class T>
struct HasX<T, std::void_t<decltype(T::mX)>> : std::true_type
concept HasData = requires
{
T::mData;
};
template <class T>
inline constexpr bool hasX = HasX<T>::value;
template <class T, class = std::void_t<>>
struct HasY : std::false_type
{
};
template <class T>
struct HasY<T, std::void_t<decltype(T::mY)>> : std::true_type
{
};
template <class T>
inline constexpr bool hasY = HasY<T>::value;
template <class T, class = std::void_t<>>
struct HasNif : std::false_type
{
};
template <class T>
struct HasNif<T, std::void_t<decltype(T::mNif)>> : std::true_type
{
};
template <class T>
inline constexpr bool hasNif = HasNif<T>::value;
template <class T, class = std::void_t<>>
struct HasKf : std::false_type
{
};
template <class T>
struct HasKf<T, std::void_t<decltype(T::mKf)>> : std::true_type
{
};
template <class T>
inline constexpr bool hasKf = HasKf<T>::value;
template <class T, class = std::void_t<>>
struct HasType : std::false_type
{
};
template <class T>
struct HasType<T, std::void_t<decltype(T::mType)>> : std::true_type
{
};
template <class T>
inline constexpr bool hasType = HasType<T>::value;
template <class T, class = std::void_t<>>
struct HasValue : std::false_type
{
};
template <class T>
struct HasValue<T, std::void_t<decltype(T::mValue)>> : std::true_type
{
};
template <class T>
inline constexpr bool hasValue = HasValue<T>::value;
template <class T, class = std::void_t<>>
struct HasData : std::false_type
{
};
template <class T>
struct HasData<T, std::void_t<decltype(T::mData)>> : std::true_type
{
};
template <class T>
inline constexpr bool hasData = HasData<T>::value;
}
#endif // OPENMW_COMPONENTS_ESM4_TYPETRAITS
+6 -16
View File
@@ -5,6 +5,7 @@
#include <components/debug/debuglog.hpp>
#include <components/esm/defs.hpp>
#include <components/esm/typetraits.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/loadacti.hpp>
#include <components/esm3/loadcell.hpp>
@@ -30,7 +31,6 @@
#include <sstream>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
@@ -64,21 +64,11 @@ namespace EsmLoader
std::map<std::pair<int, int>, std::size_t> mByPosition;
};
template <class T, class = std::void_t<>>
struct HasId : std::false_type
{
};
template <class T>
struct HasId<T, std::void_t<decltype(T::mId)>> : std::true_type
{
};
concept NotHasId = !ESM::HasId<T>;
template <class T>
constexpr bool hasId = HasId<T>::value;
template <class T>
auto loadRecord(ESM::ESMReader& reader, Records<T>& records) -> std::enable_if_t<hasId<T>>
template <ESM::HasId T>
void loadRecord(ESM::ESMReader& reader, Records<T>& records)
{
T record;
bool deleted = false;
@@ -88,8 +78,8 @@ namespace EsmLoader
records.emplace_back(deleted, std::move(record));
}
template <class T>
auto loadRecord(ESM::ESMReader& reader, Records<T>& records) -> std::enable_if_t<!hasId<T>>
template <NotHasId T>
void loadRecord(ESM::ESMReader& reader, Records<T>& records)
{
T record;
bool deleted = false;