AxioDL/metaforce
2
0
Fork 0
mirror of https://github.com/AxioDL/metaforce.git synced 2025-06-06 23:53:29 +00:00
Code Issues Projects Releases Wiki Activity

DNACommon: Mark hash overloads as noexcept

Browse Source 
These functions shouldn't throw at all.

By extension, also mark the UniqueID class interfaces as noexcept.
This commit is contained in:
Lioncash 2020-03-31 16:50:09 -04:00
parent 96fa7af8b5
commit d337327b97
1 changed files with 46 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
DataSpec/DNACommon/DNACommon.hpp
View File

@ -118,40 +118,40 @@ public:
using value_type = uint32_t; using value_type = uint32_t;
static UniqueID32 kInvalidId; static UniqueID32 kInvalidId;
AT_DECL_EXPLICIT_DNA_YAML AT_DECL_EXPLICIT_DNA_YAML
bool isValid() const { return m_id != 0xffffffff && m_id != 0; } bool isValid() const noexcept { return m_id != 0xffffffff && m_id != 0; }
void assign(uint32_t id) { m_id = id ? id : 0xffffffff; } void assign(uint32_t id) noexcept { m_id = id ? id : 0xffffffff; }
UniqueID32& operator=(const hecl::ProjectPath& path) { UniqueID32& operator=(const hecl::ProjectPath& path) noexcept {
assign(path.parsedHash32()); assign(path.parsedHash32());
return *this; return *this;
} }
bool operator!=(const UniqueID32& other) const { return m_id != other.m_id; } bool operator!=(const UniqueID32& other) const noexcept { return m_id != other.m_id; }
bool operator==(const UniqueID32& other) const { return m_id == other.m_id; } bool operator==(const UniqueID32& other) const noexcept { return m_id == other.m_id; }
bool operator<(const UniqueID32& other) const { return m_id < other.m_id; } bool operator<(const UniqueID32& other) const noexcept { return m_id < other.m_id; }
uint32_t toUint32() const { return m_id; } uint32_t toUint32() const noexcept { return m_id; }
uint64_t toUint64() const { return m_id; } uint64_t toUint64() const noexcept { return m_id; }
std::string toString() const; std::string toString() const;
void clear() { m_id = 0xffffffff; } void clear() noexcept { m_id = 0xffffffff; }
UniqueID32() = default; UniqueID32() noexcept = default;
UniqueID32(uint32_t idin) { assign(idin); } UniqueID32(uint32_t idin) noexcept { assign(idin); }
UniqueID32(athena::io::IStreamReader& reader) { read(reader); } UniqueID32(athena::io::IStreamReader& reader) { read(reader); }
UniqueID32(const hecl::ProjectPath& path) { *this = path; } UniqueID32(const hecl::ProjectPath& path) noexcept { *this = path; }
UniqueID32(const char* hexStr) { UniqueID32(const char* hexStr) noexcept {
char copy[9]; char copy[9];
strncpy(copy, hexStr, 8); strncpy(copy, hexStr, 8);
copy[8] = '\0'; copy[8] = '\0';
assign(strtoul(copy, nullptr, 16)); assign(strtoul(copy, nullptr, 16));
} }
UniqueID32(const wchar_t* hexStr) { UniqueID32(const wchar_t* hexStr) noexcept{
wchar_t copy[9]; wchar_t copy[9];
wcsncpy(copy, hexStr, 8); wcsncpy(copy, hexStr, 8);
copy[8] = L'\0'; copy[8] = L'\0';
assign(wcstoul(copy, nullptr, 16)); assign(wcstoul(copy, nullptr, 16));
} }
static constexpr size_t BinarySize() { return 4; } static constexpr size_t BinarySize() noexcept { return 4; }
}; };
/** PAK 32-bit Unique ID - writes zero when invalid */ /** PAK 32-bit Unique ID - writes zero when invalid */
@ -169,39 +169,39 @@ class UniqueID64 : public BigDNA {
public: public:
using value_type = uint64_t; using value_type = uint64_t;
AT_DECL_EXPLICIT_DNA_YAML AT_DECL_EXPLICIT_DNA_YAML
bool isValid() const { return m_id != 0xffffffffffffffff && m_id != 0; } bool isValid() const noexcept { return m_id != 0xffffffffffffffff && m_id != 0; }
void assign(uint64_t id) { m_id = id ? id : 0xffffffffffffffff; } void assign(uint64_t id) noexcept { m_id = id ? id : 0xffffffffffffffff; }
UniqueID64& operator=(const hecl::ProjectPath& path) { UniqueID64& operator=(const hecl::ProjectPath& path) noexcept {
assign(path.hash().val64()); assign(path.hash().val64());
return *this; return *this;
} }
bool operator!=(const UniqueID64& other) const { return m_id != other.m_id; } bool operator!=(const UniqueID64& other) const noexcept { return m_id != other.m_id; }
bool operator==(const UniqueID64& other) const { return m_id == other.m_id; } bool operator==(const UniqueID64& other) const noexcept { return m_id == other.m_id; }
bool operator<(const UniqueID64& other) const { return m_id < other.m_id; } bool operator<(const UniqueID64& other) const noexcept { return m_id < other.m_id; }
uint64_t toUint64() const { return m_id; } uint64_t toUint64() const noexcept { return m_id; }
std::string toString() const; std::string toString() const;
void clear() { m_id = 0xffffffffffffffff; } void clear() noexcept { m_id = 0xffffffffffffffff; }
UniqueID64() = default; UniqueID64() noexcept = default;
UniqueID64(uint64_t idin) { assign(idin); } UniqueID64(uint64_t idin) noexcept { assign(idin); }
UniqueID64(athena::io::IStreamReader& reader) { read(reader); } UniqueID64(athena::io::IStreamReader& reader) { read(reader); }
UniqueID64(const hecl::ProjectPath& path) { *this = path; } UniqueID64(const hecl::ProjectPath& path) noexcept { *this = path; }
UniqueID64(const char* hexStr) { UniqueID64(const char* hexStr) noexcept {
char copy[17]; char copy[17];
std::strncpy(copy, hexStr, 16); std::strncpy(copy, hexStr, 16);
copy[16] = '\0'; copy[16] = '\0';
assign(std::strtoull(copy, nullptr, 16)); assign(std::strtoull(copy, nullptr, 16));
} }
UniqueID64(const wchar_t* hexStr) { UniqueID64(const wchar_t* hexStr) noexcept {
wchar_t copy[17]; wchar_t copy[17];
std::wcsncpy(copy, hexStr, 16); std::wcsncpy(copy, hexStr, 16);
copy[16] = L'\0'; copy[16] = L'\0';
assign(std::wcstoull(copy, nullptr, 16)); assign(std::wcstoull(copy, nullptr, 16));
} }
static constexpr size_t BinarySize() { return 8; } static constexpr size_t BinarySize() noexcept { return 8; }
}; };
/** PAK 128-bit Unique ID */ /** PAK 128-bit Unique ID */
@ -220,26 +220,26 @@ private:
public: public:
using value_type = uint64_t; using value_type = uint64_t;
AT_DECL_EXPLICIT_DNA_YAML AT_DECL_EXPLICIT_DNA_YAML
UniqueID128() { UniqueID128() noexcept {
m_id.id[0] = 0xffffffffffffffff; m_id.id[0] = 0xffffffffffffffff;
m_id.id[1] = 0xffffffffffffffff; m_id.id[1] = 0xffffffffffffffff;
} }
UniqueID128(uint64_t idin) { UniqueID128(uint64_t idin) noexcept {
m_id.id[0] = idin; m_id.id[0] = idin;
m_id.id[1] = 0; m_id.id[1] = 0;
} }
bool isValid() const { bool isValid() const noexcept {
return m_id.id[0] != 0xffffffffffffffff && m_id.id[0] != 0 && m_id.id[1] != 0xffffffffffffffff && m_id.id[1] != 0; return m_id.id[0] != 0xffffffffffffffff && m_id.id[0] != 0 && m_id.id[1] != 0xffffffffffffffff && m_id.id[1] != 0;
} }
UniqueID128& operator=(const hecl::ProjectPath& path) { UniqueID128& operator=(const hecl::ProjectPath& path) noexcept {
m_id.id[0] = path.hash().val64(); m_id.id[0] = path.hash().val64();
m_id.id[1] = 0; m_id.id[1] = 0;
return *this; return *this;
} }
UniqueID128(const hecl::ProjectPath& path) { *this = path; } UniqueID128(const hecl::ProjectPath& path) noexcept { *this = path; }
bool operator!=(const UniqueID128& other) const { bool operator!=(const UniqueID128& other) const noexcept {
#if __SSE__ #if __SSE__
__m128i vcmp = _mm_cmpeq_epi32(m_id.id128, other.m_id.id128); __m128i vcmp = _mm_cmpeq_epi32(m_id.id128, other.m_id.id128);
int vmask = _mm_movemask_epi8(vcmp); int vmask = _mm_movemask_epi8(vcmp);
@ -248,7 +248,7 @@ public:
return (m_id.id[0] != other.m_id.id[0]) || (m_id.id[1] != other.m_id.id[1]); return (m_id.id[0] != other.m_id.id[0]) || (m_id.id[1] != other.m_id.id[1]);
#endif #endif
} }
bool operator==(const UniqueID128& other) const { bool operator==(const UniqueID128& other) const noexcept {
#if __SSE__ #if __SSE__
__m128i vcmp = _mm_cmpeq_epi32(m_id.id128, other.m_id.id128); __m128i vcmp = _mm_cmpeq_epi32(m_id.id128, other.m_id.id128);
int vmask = _mm_movemask_epi8(vcmp); int vmask = _mm_movemask_epi8(vcmp);
@ -257,19 +257,19 @@ public:
return (m_id.id[0] == other.m_id.id[0]) && (m_id.id[1] == other.m_id.id[1]); return (m_id.id[0] == other.m_id.id[0]) && (m_id.id[1] == other.m_id.id[1]);
#endif #endif
} }
bool operator<(const UniqueID128& other) const { bool operator<(const UniqueID128& other) const noexcept {
return m_id.id[0] < other.m_id.id[0] || (m_id.id[0] == other.m_id.id[0] && m_id.id[1] < other.m_id.id[1]); return m_id.id[0] < other.m_id.id[0] || (m_id.id[0] == other.m_id.id[0] && m_id.id[1] < other.m_id.id[1]);
} }
void clear() { void clear() noexcept {
m_id.id[0] = 0xffffffffffffffff; m_id.id[0] = 0xffffffffffffffff;
m_id.id[1] = 0xffffffffffffffff; m_id.id[1] = 0xffffffffffffffff;
} }
uint64_t toUint64() const { return m_id.id[0]; } uint64_t toUint64() const noexcept { return m_id.id[0]; }
uint64_t toHighUint64() const { return m_id.id[0]; } uint64_t toHighUint64() const noexcept { return m_id.id[0]; }
uint64_t toLowUint64() const { return m_id.id[1]; } uint64_t toLowUint64() const noexcept { return m_id.id[1]; }
std::string toString() const; std::string toString() const;
static constexpr size_t BinarySize() { return 16; } static constexpr size_t BinarySize() noexcept { return 16; }
}; };
/** Casts ID type to its null-zero equivalent */ /** Casts ID type to its null-zero equivalent */
@ -377,22 +377,22 @@ inline hecl::ProjectPath GetPathBeginsWith(const hecl::ProjectPath& parentPath,
namespace std { namespace std {
template <> template <>
struct hash<DataSpec::DNAFourCC> { struct hash<DataSpec::DNAFourCC> {
size_t operator()(const DataSpec::DNAFourCC& fcc) const { return fcc.toUint32(); } size_t operator()(const DataSpec::DNAFourCC& fcc) const noexcept{ return fcc.toUint32(); }
}; };
template <> template <>
struct hash<DataSpec::UniqueID32> { struct hash<DataSpec::UniqueID32> {
size_t operator()(const DataSpec::UniqueID32& id) const { return id.toUint32(); } size_t operator()(const DataSpec::UniqueID32& id) const noexcept{ return id.toUint32(); }
}; };
template <> template <>
struct hash<DataSpec::UniqueID64> { struct hash<DataSpec::UniqueID64> {
size_t operator()(const DataSpec::UniqueID64& id) const { return id.toUint64(); } size_t operator()(const DataSpec::UniqueID64& id) const noexcept{ return id.toUint64(); }
}; };
template <> template <>
struct hash<DataSpec::UniqueID128> { struct hash<DataSpec::UniqueID128> {
size_t operator()(const DataSpec::UniqueID128& id) const { return id.toHighUint64() ^ id.toLowUint64(); } size_t operator()(const DataSpec::UniqueID128& id) const noexcept { return id.toHighUint64() ^ id.toLowUint64(); }
}; };
} // namespace std } // namespace std