Use concepts to check ESM record types
This commit is contained in:
+14
-14
@@ -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';
|
||||
}
|
||||
|
||||
@@ -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))
|
||||
{
|
||||
|
||||
@@ -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;
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -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);
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
@@ -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
|
||||
|
||||
@@ -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;
|
||||
|
||||
Reference in New Issue
Block a user