libAthena
/
athena
mirror of https://github.com/libAthena/athena.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #45 from libAthena/revert-42-inline 

Revert "General: Minor general cleanup"
This commit is contained in:
Phillip Stephens 2019-08-15 08:53:06 -07:00 committed by GitHub
parent 4af15d46c9 af59ea2d48
commit 40d7396f22
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
24 changed files with 302 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/LZ77/LZType10.hpp
View File

@ -6,6 +6,6 @@ class LZType10 : public LZBase {
public: public:
explicit LZType10(atInt32 minimumOffset = 1, atInt32 SlidingWindow = 4096, atInt32 MinimumMatch = 3, explicit LZType10(atInt32 minimumOffset = 1, atInt32 SlidingWindow = 4096, atInt32 MinimumMatch = 3,
atInt32 BlockSize = 8); atInt32 BlockSize = 8);
atUint32 compress(const atUint8* src, atUint8** dstBuf, atUint32 srcLength) override; atUint32 compress(const atUint8* src, atUint8** dstBuf, atUint32 srcLength);
atUint32 decompress(const atUint8* src, atUint8** dst, atUint32 srcLen) override; atUint32 decompress(const atUint8* src, atUint8** dst, atUint32 srcLen);
}; };

4
include/LZ77/LZType11.hpp
View File

@ -6,6 +6,6 @@ class LZType11 : public LZBase {
public: public:
explicit LZType11(atInt32 MinimumOffset = 1, atInt32 SlidingWindow = 4096, atInt32 MinimumMatch = 3, explicit LZType11(atInt32 MinimumOffset = 1, atInt32 SlidingWindow = 4096, atInt32 MinimumMatch = 3,
atInt32 BlockSize = 8); atInt32 BlockSize = 8);
atUint32 compress(const atUint8* src, atUint8** dst, atUint32 srcLength) override; atUint32 compress(const atUint8* src, atUint8** dst, atUint32 srcLength);
atUint32 decompress(const atUint8* src, atUint8** dst, atUint32 srcLength) override; atUint32 decompress(const atUint8* src, atUint8** dst, atUint32 srcLength);
}; };

175
include/athena/DNAOp.hpp
View File

@ -56,16 +56,16 @@ constexpr PropId operator"" _propid(const char* s, size_t len) { return {s}; }
enum class PropType { None, CRC32, CRC64 }; enum class PropType { None, CRC32, CRC64 };
template <class T> template <class T>
using __IsPODType = std::disjunction< using __IsPODType = typename std::disjunction<
std::is_arithmetic<std::remove_cv_t<T>>, std::is_convertible<std::remove_cv_t<T>&, atVec2f&>, std::is_arithmetic<std::remove_cv_t<T>>, std::is_convertible<std::remove_cv_t<T>&, atVec2f&>,
std::is_convertible<std::remove_cv_t<T>&, atVec3f&>, std::is_convertible<std::remove_cv_t<T>&, atVec4f&>, std::is_convertible<std::remove_cv_t<T>&, atVec3f&>, std::is_convertible<std::remove_cv_t<T>&, atVec4f&>,
std::is_convertible<std::remove_cv_t<T>&, atVec2d&>, std::is_convertible<std::remove_cv_t<T>&, atVec3d&>, std::is_convertible<std::remove_cv_t<T>&, atVec2d&>, std::is_convertible<std::remove_cv_t<T>&, atVec3d&>,
std::is_convertible<std::remove_cv_t<T>&, atVec4d&>>; std::is_convertible<std::remove_cv_t<T>&, atVec4d&>>;
template <class T> template <class T>
constexpr bool __IsPODType_v = __IsPODType<T>::value; inline constexpr bool __IsPODType_v = __IsPODType<T>::value;
template <class T> template <class T>
using __CastPODType = std::conditional_t< using __CastPODType = typename std::conditional_t<
std::is_convertible_v<std::remove_cv_t<T>&, atVec2f&>, atVec2f, std::is_convertible_v<std::remove_cv_t<T>&, atVec2f&>, atVec2f,
std::conditional_t< std::conditional_t<
std::is_convertible_v<std::remove_cv_t<T>&, atVec3f&>, atVec3f, std::is_convertible_v<std::remove_cv_t<T>&, atVec3f&>, atVec3f,
@ -78,32 +78,32 @@ using __CastPODType = std::conditional_t<
std::remove_cv_t<T>>>>>>>; std::remove_cv_t<T>>>>>>>;
template <Endian DNAE> template <Endian DNAE>
uint16_t __Read16(IStreamReader& r) { inline uint16_t __Read16(IStreamReader& r) {
return DNAE == Endian::Big ? r.readUint16Big() : r.readUint16Little(); return DNAE == Endian::Big ? r.readUint16Big() : r.readUint16Little();
} }
template <Endian DNAE> template <Endian DNAE>
void __Write16(IStreamWriter& w, uint16_t v) { inline void __Write16(IStreamWriter& w, uint16_t v) {
DNAE == Endian::Big ? w.writeUint16Big(v) : w.writeUint16Little(v); DNAE == Endian::Big ? w.writeUint16Big(v) : w.writeUint16Little(v);
} }
template <Endian DNAE> template <Endian DNAE>
uint32_t __Read32(IStreamReader& r) { inline uint32_t __Read32(IStreamReader& r) {
return DNAE == Endian::Big ? r.readUint32Big() : r.readUint32Little(); return DNAE == Endian::Big ? r.readUint32Big() : r.readUint32Little();
} }
template <Endian DNAE> template <Endian DNAE>
void __Write32(IStreamWriter& w, uint32_t v) { inline void __Write32(IStreamWriter& w, uint32_t v) {
DNAE == Endian::Big ? w.writeUint32Big(v) : w.writeUint32Little(v); DNAE == Endian::Big ? w.writeUint32Big(v) : w.writeUint32Little(v);
} }
template <Endian DNAE> template <Endian DNAE>
uint64_t __Read64(IStreamReader& r) { inline uint64_t __Read64(IStreamReader& r) {
return DNAE == Endian::Big ? r.readUint64Big() : r.readUint64Little(); return DNAE == Endian::Big ? r.readUint64Big() : r.readUint64Little();
} }
template <Endian DNAE> template <Endian DNAE>
void __Write64(IStreamWriter& w, uint64_t v) { inline void __Write64(IStreamWriter& w, uint64_t v) {
DNAE == Endian::Big ? w.writeUint64Big(v) : w.writeUint64Little(v); DNAE == Endian::Big ? w.writeUint64Big(v) : w.writeUint64Little(v);
} }
@ -112,7 +112,7 @@ struct BinarySize {
using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>; using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>;
using StreamT = size_t; using StreamT = size_t;
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_enum_v<T>> Do(const PropId& id, T& var, StreamT& s) { static typename std::enable_if_t<std::is_enum_v<T>> Do(const PropId& id, T& var, StreamT& s) {
if (PropOp != PropType::None) { if (PropOp != PropType::None) {
/* Accessed via Enumerate, header */ /* Accessed via Enumerate, header */
s += 6; s += 6;
@ -121,7 +121,7 @@ struct BinarySize {
BinarySize<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), s); BinarySize<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), s);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<__IsPODType_v<T>> Do(const PropId& id, T& var, StreamT& s) { static typename std::enable_if_t<__IsPODType_v<T>> Do(const PropId& id, T& var, StreamT& s) {
if (PropOp != PropType::None) { if (PropOp != PropType::None) {
/* Accessed via Enumerate, header */ /* Accessed via Enumerate, header */
s += 6; s += 6;
@ -130,17 +130,19 @@ struct BinarySize {
BinarySize<PropType::None>::Do<CastT, DNAE>(id, static_cast<CastT&>(const_cast<std::remove_cv_t<T>&>(var)), s); BinarySize<PropType::None>::Do<CastT, DNAE>(id, static_cast<CastT&>(const_cast<std::remove_cv_t<T>&>(var)), s);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<__IsDNARecord_v<T> && PropOp != PropType::None> Do(const PropId& id, T& var, StreamT& s) { static typename std::enable_if_t<__IsDNARecord_v<T> && PropOp != PropType::None> Do(const PropId& id, T& var,
StreamT& s) {
/* Accessed via Enumerate, header */ /* Accessed via Enumerate, header */
s += 6; s += 6;
var.template Enumerate<BinarySize<PropOp>>(s); var.template Enumerate<BinarySize<PropOp>>(s);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<__IsDNARecord_v<T> && PropOp == PropType::None> Do(const PropId& id, T& var, StreamT& s) { static typename std::enable_if_t<__IsDNARecord_v<T> && PropOp == PropType::None> Do(const PropId& id, T& var,
StreamT& s) {
var.template Enumerate<BinarySize<PropType::None>>(s); var.template Enumerate<BinarySize<PropType::None>>(s);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_array_v<T>> Do(const PropId& id, T& var, StreamT& s) { static typename std::enable_if_t<std::is_array_v<T>> Do(const PropId& id, T& var, StreamT& s) {
for (auto& v : var) for (auto& v : var)
BinarySize<PropOp>::Do<std::remove_reference_t<decltype(v)>, DNAE>(id, v, s); BinarySize<PropOp>::Do<std::remove_reference_t<decltype(v)>, DNAE>(id, v, s);
} }
@ -149,14 +151,14 @@ struct BinarySize {
BinarySize<PropOp>::Do<T, DNAE>(id, var, s); BinarySize<PropOp>::Do<T, DNAE>(id, var, s);
} }
template <class T, class S, Endian DNAE> template <class T, class S, Endian DNAE>
static std::enable_if_t<!std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count, static typename std::enable_if_t<!std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector,
StreamT& s) { const S& count, StreamT& s) {
for (T& v : vector) for (T& v : vector)
BinarySize<PropOp>::Do<T, DNAE>(id, v, s); BinarySize<PropOp>::Do<T, DNAE>(id, v, s);
} }
template <class T, class S, Endian DNAE> template <class T, class S, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count, static typename std::enable_if_t<std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count,
StreamT& s) { StreamT& s) {
/* libc++ specializes vector<bool> as a bitstream */ /* libc++ specializes vector<bool> as a bitstream */
s += vector.size(); s += vector.size();
} }
@ -165,7 +167,7 @@ struct BinarySize {
s += count; s += count;
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, std::string>> Do(const PropId& id, T& str, StreamT& s) { static typename std::enable_if_t<std::is_same_v<T, std::string>> Do(const PropId& id, T& str, StreamT& s) {
s += str.size() + 1; s += str.size() + 1;
} }
static void Do(const PropId& id, std::string& str, atInt32 count, StreamT& s) { static void Do(const PropId& id, std::string& str, atInt32 count, StreamT& s) {
@ -175,7 +177,7 @@ struct BinarySize {
s += count; s += count;
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, std::wstring>> Do(const PropId& id, T& str, StreamT& s) { static typename std::enable_if_t<std::is_same_v<T, std::wstring>> Do(const PropId& id, T& str, StreamT& s) {
s += str.size() * 2 + 2; s += str.size() * 2 + 2;
} }
template <Endian DNAE> template <Endian DNAE>
@ -261,7 +263,7 @@ struct PropCount {
s += 1; s += 1;
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, std::string>> Do(const PropId& id, T& str, StreamT& s) { static typename std::enable_if_t<std::is_same_v<T, std::string>> Do(const PropId& id, T& str, StreamT& s) {
/* Only reports one level of properties */ /* Only reports one level of properties */
s += 1; s += 1;
} }
@ -270,7 +272,7 @@ struct PropCount {
s += 1; s += 1;
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, std::wstring>> Do(const PropId& id, T& str, StreamT& s) { static typename std::enable_if_t<std::is_same_v<T, std::wstring>> Do(const PropId& id, T& str, StreamT& s) {
/* Only reports one level of properties */ /* Only reports one level of properties */
s += 1; s += 1;
} }
@ -288,21 +290,23 @@ struct Read {
using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>; using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>;
using StreamT = IStreamReader; using StreamT = IStreamReader;
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_enum_v<T>> Do(const PropId& id, T& var, StreamT& r) { static typename std::enable_if_t<std::is_enum_v<T>> Do(const PropId& id, T& var, StreamT& r) {
using PODType = std::underlying_type_t<T>; using PODType = std::underlying_type_t<T>;
Read<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), r); Read<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), r);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<__IsPODType_v<T>> Do(const PropId& id, T& var, StreamT& r) { static typename std::enable_if_t<__IsPODType_v<T>> Do(const PropId& id, T& var, StreamT& r) {
using CastT = __CastPODType<T>; using CastT = __CastPODType<T>;
Read<PropType::None>::Do<CastT, DNAE>(id, static_cast<CastT&>(var), r); Read<PropType::None>::Do<CastT, DNAE>(id, static_cast<CastT&>(var), r);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<__IsDNARecord<T>() && PropOp == PropType::None> Do(const PropId& id, T& var, StreamT& r) { static typename std::enable_if_t<__IsDNARecord<T>() && PropOp == PropType::None> Do(const PropId& id, T& var,
StreamT& r) {
var.template Enumerate<Read<PropType::None>>(r); var.template Enumerate<Read<PropType::None>>(r);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<__IsDNARecord<T>() && PropOp != PropType::None> Do(const PropId& id, T& var, StreamT& r) { static typename std::enable_if_t<__IsDNARecord<T>() && PropOp != PropType::None> Do(const PropId& id, T& var,
StreamT& r) {
/* Accessed via Lookup, no header */ /* Accessed via Lookup, no header */
atUint16 propCount = __Read16<T::DNAEndian>(r); atUint16 propCount = __Read16<T::DNAEndian>(r);
for (atUint32 i = 0; i < propCount; ++i) { for (atUint32 i = 0; i < propCount; ++i) {
@ -320,7 +324,7 @@ struct Read {
} }
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_array_v<T>> Do(const PropId& id, T& var, StreamT& s) { static typename std::enable_if_t<std::is_array_v<T>> Do(const PropId& id, T& var, StreamT& s) {
for (auto& v : var) for (auto& v : var)
Read<PropOp>::Do<std::remove_reference_t<decltype(v)>, DNAE>(id, v, s); Read<PropOp>::Do<std::remove_reference_t<decltype(v)>, DNAE>(id, v, s);
} }
@ -329,8 +333,8 @@ struct Read {
Read<PropOp>::Do<T, DNAE>(id, var, s); Read<PropOp>::Do<T, DNAE>(id, var, s);
} }
template <class T, class S, Endian DNAE> template <class T, class S, Endian DNAE>
static std::enable_if_t<!std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count, static typename std::enable_if_t<!std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector,
StreamT& r) { const S& count, StreamT& r) {
vector.clear(); vector.clear();
vector.reserve(count); vector.reserve(count);
for (size_t i = 0; i < static_cast<size_t>(count); ++i) { for (size_t i = 0; i < static_cast<size_t>(count); ++i) {
@ -339,8 +343,8 @@ struct Read {
} }
} }
template <class T, class S, Endian DNAE> template <class T, class S, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count, static typename std::enable_if_t<std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count,
StreamT& r) { StreamT& r) {
/* libc++ specializes vector<bool> as a bitstream */ /* libc++ specializes vector<bool> as a bitstream */
vector.clear(); vector.clear();
vector.reserve(count); vector.reserve(count);
@ -352,12 +356,12 @@ struct Read {
r.readUBytesToBuf(buf.get(), count); r.readUBytesToBuf(buf.get(), count);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, std::string>> Do(const PropId& id, T& str, StreamT& r) { static typename std::enable_if_t<std::is_same_v<T, std::string>> Do(const PropId& id, T& str, StreamT& r) {
str = r.readString(); str = r.readString();
} }
static void Do(const PropId& id, std::string& str, atInt32 count, StreamT& r) { str = r.readString(count); } static void Do(const PropId& id, std::string& str, atInt32 count, StreamT& r) { str = r.readString(count); }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, std::wstring>> Do(const PropId& id, T& str, StreamT& r) { static typename std::enable_if_t<std::is_same_v<T, std::wstring>> Do(const PropId& id, T& str, StreamT& r) {
Read<PropType::None>::Do<DNAE>(id, str, r); Read<PropType::None>::Do<DNAE>(id, str, r);
} }
template <Endian DNAE> template <Endian DNAE>
@ -425,7 +429,7 @@ struct Write {
using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>; using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>;
using StreamT = IStreamWriter; using StreamT = IStreamWriter;
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_enum_v<T>> Do(const PropId& id, T& var, StreamT& w) { static typename std::enable_if_t<std::is_enum_v<T>> Do(const PropId& id, T& var, StreamT& w) {
if (PropOp != PropType::None) { if (PropOp != PropType::None) {
/* Accessed via Enumerate, header */ /* Accessed via Enumerate, header */
if (PropOp == PropType::CRC64) if (PropOp == PropType::CRC64)
@ -440,7 +444,7 @@ struct Write {
Write<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), w); Write<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), w);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<__IsPODType_v<T>> Do(const PropId& id, T& var, StreamT& w) { static typename std::enable_if_t<__IsPODType_v<T>> Do(const PropId& id, T& var, StreamT& w) {
using CastT = __CastPODType<T>; using CastT = __CastPODType<T>;
if (PropOp != PropType::None) { if (PropOp != PropType::None) {
/* Accessed via Enumerate, header */ /* Accessed via Enumerate, header */
@ -456,7 +460,8 @@ struct Write {
Write<PropType::None>::Do<CastT, DNAE>(id, static_cast<CastT&>(const_cast<std::remove_cv_t<T>&>(var)), w); Write<PropType::None>::Do<CastT, DNAE>(id, static_cast<CastT&>(const_cast<std::remove_cv_t<T>&>(var)), w);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<__IsDNARecord<T>() && PropOp != PropType::None> Do(const PropId& id, T& var, StreamT& w) { static typename std::enable_if_t<__IsDNARecord<T>() && PropOp != PropType::None> Do(const PropId& id, T& var,
StreamT& w) {
/* Accessed via Enumerate, header */ /* Accessed via Enumerate, header */
if (PropOp == PropType::CRC64) if (PropOp == PropType::CRC64)
__Write64<T::DNAEndian>(w, id.crc64); __Write64<T::DNAEndian>(w, id.crc64);
@ -472,11 +477,12 @@ struct Write {
var.template Enumerate<Write<PropOp>>(w); var.template Enumerate<Write<PropOp>>(w);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<__IsDNARecord<T>() && PropOp == PropType::None> Do(const PropId& id, T& var, StreamT& w) { static typename std::enable_if_t<__IsDNARecord<T>() && PropOp == PropType::None> Do(const PropId& id, T& var,
StreamT& w) {
var.template Enumerate<Write<PropType::None>>(w); var.template Enumerate<Write<PropType::None>>(w);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_array_v<T>> Do(const PropId& id, T& var, StreamT& s) { static typename std::enable_if_t<std::is_array_v<T>> Do(const PropId& id, T& var, StreamT& s) {
for (auto& v : var) for (auto& v : var)
Write<PropOp>::Do<std::remove_reference_t<decltype(v)>, DNAE>(id, v, s); Write<PropOp>::Do<std::remove_reference_t<decltype(v)>, DNAE>(id, v, s);
} }
@ -485,14 +491,14 @@ struct Write {
Write<PropOp>::Do<T, DNAE>(id, var, s); Write<PropOp>::Do<T, DNAE>(id, var, s);
} }
template <class T, class S, Endian DNAE> template <class T, class S, Endian DNAE>
static std::enable_if_t<!std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count, static typename std::enable_if_t<!std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector,
StreamT& w) { const S& count, StreamT& w) {
for (T& v : vector) for (T& v : vector)
Write<PropOp>::Do<T, DNAE>(id, v, w); Write<PropOp>::Do<T, DNAE>(id, v, w);
} }
template <class T, class S, Endian DNAE> template <class T, class S, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count, static typename std::enable_if_t<std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count,
StreamT& w) { StreamT& w) {
/* libc++ specializes vector<bool> as a bitstream */ /* libc++ specializes vector<bool> as a bitstream */
for (const T& v : vector) for (const T& v : vector)
w.writeBool(v); w.writeBool(v);
@ -502,12 +508,13 @@ struct Write {
w.writeUBytes(buf.get(), count); w.writeUBytes(buf.get(), count);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, std::string>> Do(const PropId& id, std::string& str, StreamT& w) { static typename std::enable_if_t<std::is_same_v<T, std::string>> Do(const PropId& id, std::string& str, StreamT& w) {
w.writeString(str); w.writeString(str);
} }
static void Do(const PropId& id, std::string& str, atInt32 count, StreamT& w) { w.writeString(str, count); } static void Do(const PropId& id, std::string& str, atInt32 count, StreamT& w) { w.writeString(str, count); }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, std::wstring>> Do(const PropId& id, std::wstring& str, StreamT& w) { static typename std::enable_if_t<std::is_same_v<T, std::wstring>> Do(const PropId& id, std::wstring& str,
StreamT& w) {
Write<PropType::None>::Do<DNAE>(id, str, w); Write<PropType::None>::Do<DNAE>(id, str, w);
} }
template <Endian DNAE> template <Endian DNAE>
@ -573,22 +580,22 @@ struct ReadYaml {
using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>; using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>;
using StreamT = YAMLDocReader; using StreamT = YAMLDocReader;
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_enum_v<T>> Do(const PropId& id, T& var, StreamT& r) { static typename std::enable_if_t<std::is_enum_v<T>> Do(const PropId& id, T& var, StreamT& r) {
using PODType = std::underlying_type_t<T>; using PODType = std::underlying_type_t<T>;
ReadYaml<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), r); ReadYaml<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), r);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<__IsPODType_v<T>> Do(const PropId& id, T& var, StreamT& r) { static typename std::enable_if_t<__IsPODType_v<T>> Do(const PropId& id, T& var, StreamT& r) {
using CastT = __CastPODType<T>; using CastT = __CastPODType<T>;
ReadYaml<PropType::None>::Do<CastT, DNAE>(id, static_cast<CastT&>(var), r); ReadYaml<PropType::None>::Do<CastT, DNAE>(id, static_cast<CastT&>(var), r);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<__IsDNARecord_v<T>> Do(const PropId& id, T& var, StreamT& r) { static typename std::enable_if_t<__IsDNARecord_v<T>> Do(const PropId& id, T& var, StreamT& r) {
if (auto rec = r.enterSubRecord(id.name)) if (auto rec = r.enterSubRecord(id.name))
var.template Enumerate<ReadYaml<PropOp>>(r); var.template Enumerate<ReadYaml<PropOp>>(r);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_array_v<T>> Do(const PropId& id, T& var, StreamT& r) { static typename std::enable_if_t<std::is_array_v<T>> Do(const PropId& id, T& var, StreamT& r) {
size_t _count; size_t _count;
if (auto __v = r.enterSubVector(id.name, _count)) if (auto __v = r.enterSubVector(id.name, _count))
for (size_t i = 0; i < _count && i < std::extent_v<T>; ++i) for (size_t i = 0; i < _count && i < std::extent_v<T>; ++i)
@ -599,8 +606,8 @@ struct ReadYaml {
/* Squelch size field access */ /* Squelch size field access */
} }
template <class T, class S, Endian DNAE> template <class T, class S, Endian DNAE>
static std::enable_if_t<!std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count, static typename std::enable_if_t<!std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector,
StreamT& r) { const S& count, StreamT& r) {
size_t _count; size_t _count;
vector.clear(); vector.clear();
if (auto __v = r.enterSubVector(id.name, _count)) { if (auto __v = r.enterSubVector(id.name, _count)) {
@ -614,8 +621,8 @@ struct ReadYaml {
const_cast<S&>(count) = vector.size(); const_cast<S&>(count) = vector.size();
} }
template <class T, class S, Endian DNAE> template <class T, class S, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count, static typename std::enable_if_t<std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count,
StreamT& r) { StreamT& r) {
/* libc++ specializes vector<bool> as a bitstream */ /* libc++ specializes vector<bool> as a bitstream */
size_t _count; size_t _count;
vector.clear(); vector.clear();
@ -631,12 +638,12 @@ struct ReadYaml {
buf = r.readUBytes(id.name); buf = r.readUBytes(id.name);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, std::string>> Do(const PropId& id, T& str, StreamT& r) { static typename std::enable_if_t<std::is_same_v<T, std::string>> Do(const PropId& id, T& str, StreamT& r) {
str = r.readString(id.name); str = r.readString(id.name);
} }
static void Do(const PropId& id, std::string& str, atInt32 count, StreamT& r) { str = r.readString(id.name); } static void Do(const PropId& id, std::string& str, atInt32 count, StreamT& r) { str = r.readString(id.name); }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, std::wstring>> Do(const PropId& id, T& str, StreamT& r) { static typename std::enable_if_t<std::is_same_v<T, std::wstring>> Do(const PropId& id, T& str, StreamT& r) {
str = r.readWString(id.name); str = r.readWString(id.name);
} }
template <Endian DNAE> template <Endian DNAE>
@ -690,22 +697,22 @@ struct WriteYaml {
using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>; using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>;
using StreamT = YAMLDocWriter; using StreamT = YAMLDocWriter;
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_enum_v<T>> Do(const PropId& id, T& var, StreamT& w) { static typename std::enable_if_t<std::is_enum_v<T>> Do(const PropId& id, T& var, StreamT& w) {
using PODType = std::underlying_type_t<T>; using PODType = std::underlying_type_t<T>;
WriteYaml<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), w); WriteYaml<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), w);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<__IsPODType_v<T>> Do(const PropId& id, T& var, StreamT& w) { static typename std::enable_if_t<__IsPODType_v<T>> Do(const PropId& id, T& var, StreamT& w) {
using CastT = __CastPODType<T>; using CastT = __CastPODType<T>;
WriteYaml<PropType::None>::Do<CastT, DNAE>(id, static_cast<CastT&>(const_cast<std::remove_cv_t<T>&>(var)), w); WriteYaml<PropType::None>::Do<CastT, DNAE>(id, static_cast<CastT&>(const_cast<std::remove_cv_t<T>&>(var)), w);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<__IsDNARecord_v<T>> Do(const PropId& id, T& var, StreamT& w) { static typename std::enable_if_t<__IsDNARecord_v<T>> Do(const PropId& id, T& var, StreamT& w) {
if (auto rec = w.enterSubRecord(id.name)) if (auto rec = w.enterSubRecord(id.name))
var.template Enumerate<WriteYaml<PropOp>>(w); var.template Enumerate<WriteYaml<PropOp>>(w);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_array_v<T>> Do(const PropId& id, T& var, StreamT& w) { static typename std::enable_if_t<std::is_array_v<T>> Do(const PropId& id, T& var, StreamT& w) {
if (auto __v = w.enterSubVector(id.name)) if (auto __v = w.enterSubVector(id.name))
for (auto& v : var) for (auto& v : var)
WriteYaml<PropOp>::Do<std::remove_reference_t<decltype(v)>, DNAE>({}, v, w); WriteYaml<PropOp>::Do<std::remove_reference_t<decltype(v)>, DNAE>({}, v, w);
@ -715,15 +722,15 @@ struct WriteYaml {
/* Squelch size field access */ /* Squelch size field access */
} }
template <class T, class S, Endian DNAE> template <class T, class S, Endian DNAE>
static std::enable_if_t<!std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count, static typename std::enable_if_t<!std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector,
StreamT& w) { const S& count, StreamT& w) {
if (auto __v = w.enterSubVector(id.name)) if (auto __v = w.enterSubVector(id.name))
for (T& v : vector) for (T& v : vector)
WriteYaml<PropOp>::Do<T, DNAE>(id, v, w); WriteYaml<PropOp>::Do<T, DNAE>(id, v, w);
} }
template <class T, class S, Endian DNAE> template <class T, class S, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count, static typename std::enable_if_t<std::is_same_v<T, bool>> Do(const PropId& id, std::vector<T>& vector, const S& count,
StreamT& w) { StreamT& w) {
/* libc++ specializes vector<bool> as a bitstream */ /* libc++ specializes vector<bool> as a bitstream */
if (auto __v = w.enterSubVector(id.name)) if (auto __v = w.enterSubVector(id.name))
for (const T& v : vector) for (const T& v : vector)
@ -733,12 +740,12 @@ struct WriteYaml {
w.writeUBytes(id.name, buf, count); w.writeUBytes(id.name, buf, count);
} }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, std::string>> Do(const PropId& id, T& str, StreamT& w) { static typename std::enable_if_t<std::is_same_v<T, std::string>> Do(const PropId& id, T& str, StreamT& w) {
w.writeString(id.name, str); w.writeString(id.name, str);
} }
static void Do(const PropId& id, std::string& str, atInt32 count, StreamT& w) { w.writeString(id.name, str); } static void Do(const PropId& id, std::string& str, atInt32 count, StreamT& w) { w.writeString(id.name, str); }
template <class T, Endian DNAE> template <class T, Endian DNAE>
static std::enable_if_t<std::is_same_v<T, std::wstring>> Do(const PropId& id, T& str, StreamT& w) { static typename std::enable_if_t<std::is_same_v<T, std::wstring>> Do(const PropId& id, T& str, StreamT& w) {
w.writeWString(id.name, str); w.writeWString(id.name, str);
} }
template <Endian DNAE> template <Endian DNAE>
@ -788,77 +795,77 @@ __WRITE_YAML_S(atVec4f, Endian::Little) { w.writeVec4f(id.name, var); }
__WRITE_YAML_S(atVec4d, Endian::Little) { w.writeVec4d(id.name, var); } __WRITE_YAML_S(atVec4d, Endian::Little) { w.writeVec4d(id.name, var); }
template <class Op, class T, Endian DNAE> template <class Op, class T, Endian DNAE>
void __Do(const PropId& id, T& var, typename Op::StreamT& s) { inline void __Do(const PropId& id, T& var, typename Op::StreamT& s) {
Op::template Do<T, DNAE>(id, var, s); Op::template Do<T, DNAE>(id, var, s);
} }
template <class Op, class T, Endian DNAE> template <class Op, class T, Endian DNAE>
void __DoSize(const PropId& id, T& var, typename Op::StreamT& s) { inline void __DoSize(const PropId& id, T& var, typename Op::StreamT& s) {
Op::template DoSize<T, DNAE>(id, var, s); Op::template DoSize<T, DNAE>(id, var, s);
} }
template <class Op, class T, class S, Endian DNAE> template <class Op, class T, class S, Endian DNAE>
void __Do(const PropId& id, std::vector<T>& vector, const S& count, typename Op::StreamT& s) { inline void __Do(const PropId& id, std::vector<T>& vector, const S& count, typename Op::StreamT& s) {
Op::template Do<T, S, DNAE>(id, vector, count, s); Op::template Do<T, S, DNAE>(id, vector, count, s);
} }
template <class Op> template <class Op>
void __Do(const PropId& id, std::unique_ptr<atUint8[]>& buf, size_t count, typename Op::StreamT& s) { inline void __Do(const PropId& id, std::unique_ptr<atUint8[]>& buf, size_t count, typename Op::StreamT& s) {
Op::Do(id, buf, count, s); Op::Do(id, buf, count, s);
} }
template <class Op> template <class Op>
void __Do(const PropId& id, std::string& str, atInt32 count, typename Op::StreamT& s) { inline void __Do(const PropId& id, std::string& str, atInt32 count, typename Op::StreamT& s) {
Op::Do(id, str, count, s); Op::Do(id, str, count, s);
} }
template <class Op, Endian DNAE> template <class Op, Endian DNAE>
void __Do(const PropId& id, std::wstring& str, atInt32 count, typename Op::StreamT& s) { inline void __Do(const PropId& id, std::wstring& str, atInt32 count, typename Op::StreamT& s) {
Op::template Do<DNAE>(id, str, count, s); Op::template Do<DNAE>(id, str, count, s);
} }
template <class Op> template <class Op>
void __DoSeek(atInt64 delta, athena::SeekOrigin whence, typename Op::StreamT& s) { inline void __DoSeek(atInt64 delta, athena::SeekOrigin whence, typename Op::StreamT& s) {
Op::DoSeek(delta, whence, s); Op::DoSeek(delta, whence, s);
} }
template <class Op> template <class Op>
void __DoAlign(atInt64 amount, typename Op::StreamT& s) { inline void __DoAlign(atInt64 amount, typename Op::StreamT& s) {
Op::DoAlign(amount, s); Op::DoAlign(amount, s);
} }
template <class T> template <class T>
void __Read(T& obj, athena::io::IStreamReader& r) { inline void __Read(T& obj, athena::io::IStreamReader& r) {
__Do<Read<PropType::None>, T, T::DNAEndian>({}, obj, r); __Do<Read<PropType::None>, T, T::DNAEndian>({}, obj, r);
} }
template <class T> template <class T>
void __Write(const T& obj, athena::io::IStreamWriter& w) { inline void __Write(const T& obj, athena::io::IStreamWriter& w) {
__Do<Write<PropType::None>, T, T::DNAEndian>({}, const_cast<T&>(obj), w); __Do<Write<PropType::None>, T, T::DNAEndian>({}, const_cast<T&>(obj), w);
} }
template <class T> template <class T>
void __BinarySize(const T& obj, size_t& s) { inline void __BinarySize(const T& obj, size_t& s) {
__Do<BinarySize<PropType::None>, T, T::DNAEndian>({}, const_cast<T&>(obj), s); __Do<BinarySize<PropType::None>, T, T::DNAEndian>({}, const_cast<T&>(obj), s);
} }
template <class T> template <class T>
void __PropCount(const T& obj, size_t& s) { inline void __PropCount(const T& obj, size_t& s) {
const_cast<T&>(obj).template Enumerate<PropCount<PropType::None>>(s); const_cast<T&>(obj).template Enumerate<PropCount<PropType::None>>(s);
} }
template <class T> template <class T>
void __ReadYaml(T& obj, athena::io::YAMLDocReader& r) { inline void __ReadYaml(T& obj, athena::io::YAMLDocReader& r) {
obj.template Enumerate<ReadYaml<PropType::None>>(r); obj.template Enumerate<ReadYaml<PropType::None>>(r);
} }
template <class T> template <class T>
void __WriteYaml(const T& obj, athena::io::YAMLDocWriter& w) { inline void __WriteYaml(const T& obj, athena::io::YAMLDocWriter& w) {
const_cast<T&>(obj).template Enumerate<WriteYaml<PropType::None>>(w); const_cast<T&>(obj).template Enumerate<WriteYaml<PropType::None>>(w);
} }
template <class T> template <class T>
void __ReadProp(T& obj, athena::io::IStreamReader& r) { inline void __ReadProp(T& obj, athena::io::IStreamReader& r) {
/* Read root 0xffffffff hash (hashed empty string) */ /* Read root 0xffffffff hash (hashed empty string) */
T::DNAEndian == Endian::Big ? r.readUint32Big() : r.readUint32Little(); T::DNAEndian == Endian::Big ? r.readUint32Big() : r.readUint32Little();
atInt64 size = T::DNAEndian == Endian::Big ? r.readUint16Big() : r.readUint16Little(); atInt64 size = T::DNAEndian == Endian::Big ? r.readUint16Big() : r.readUint16Little();
@ -870,17 +877,17 @@ void __ReadProp(T& obj, athena::io::IStreamReader& r) {
} }
template <class T> template <class T>
void __WriteProp(const T& obj, athena::io::IStreamWriter& w) { inline void __WriteProp(const T& obj, athena::io::IStreamWriter& w) {
__Do<Write<PropType::CRC32>, T, T::DNAEndian>({}, const_cast<T&>(obj), w); __Do<Write<PropType::CRC32>, T, T::DNAEndian>({}, const_cast<T&>(obj), w);
} }
template <class T> template <class T>
void __BinarySizeProp(const T& obj, size_t& s) { inline void __BinarySizeProp(const T& obj, size_t& s) {
__Do<BinarySize<PropType::CRC32>, T, T::DNAEndian>({}, const_cast<T&>(obj), s); __Do<BinarySize<PropType::CRC32>, T, T::DNAEndian>({}, const_cast<T&>(obj), s);
} }
template <class T> template <class T>
void __ReadProp64(T& obj, athena::io::IStreamReader& r) { inline void __ReadProp64(T& obj, athena::io::IStreamReader& r) {
/* Read root 0x0 hash (hashed empty string) */ /* Read root 0x0 hash (hashed empty string) */
T::DNAEndian == Endian::Big ? r.readUint64Big() : r.readUint64Little(); T::DNAEndian == Endian::Big ? r.readUint64Big() : r.readUint64Little();
atInt64 size = T::DNAEndian == Endian::Big ? r.readUint16Big() : r.readUint16Little(); atInt64 size = T::DNAEndian == Endian::Big ? r.readUint16Big() : r.readUint16Little();
@ -892,12 +899,12 @@ void __ReadProp64(T& obj, athena::io::IStreamReader& r) {
} }
template <class T> template <class T>
void __WriteProp64(const T& obj, athena::io::IStreamWriter& w) { inline void __WriteProp64(const T& obj, athena::io::IStreamWriter& w) {
__Do<Write<PropType::CRC64>, T, T::DNAEndian>({}, const_cast<T&>(obj), w); __Do<Write<PropType::CRC64>, T, T::DNAEndian>({}, const_cast<T&>(obj), w);
} }
template <class T> template <class T>
void __BinarySizeProp64(const T& obj, size_t& s) { inline void __BinarySizeProp64(const T& obj, size_t& s) {
__Do<BinarySize<PropType::CRC64>, T, T::DNAEndian>({}, const_cast<T&>(obj), s); __Do<BinarySize<PropType::CRC64>, T, T::DNAEndian>({}, const_cast<T&>(obj), s);
} }

23
include/athena/DNAYaml.hpp
View File

@ -9,17 +9,17 @@
namespace athena::io { namespace athena::io {
template <class T> template <class T>
const char* __GetDNAName(const T& dna, std::enable_if_t<athena::io::__IsDNAVRecord_v<T>>* = nullptr) { inline const char* __GetDNAName(const T& dna, typename std::enable_if_t<athena::io::__IsDNAVRecord_v<T>>* = 0) {
return dna.DNATypeV(); return dna.DNATypeV();
} }
template <class T> template <class T>
const char* __GetDNAName(const T& dna, std::enable_if_t<!athena::io::__IsDNAVRecord_v<T>>* = nullptr) { inline const char* __GetDNAName(const T& dna, typename std::enable_if_t<!athena::io::__IsDNAVRecord_v<T>>* = 0) {
return dna.DNAType(); return dna.DNAType();
} }
template <class T> template <class T>
std::string ToYAMLString(const T& dna) { inline std::string ToYAMLString(const T& dna) {
YAMLDocWriter docWriter(__GetDNAName(dna)); YAMLDocWriter docWriter(__GetDNAName(dna));
std::string res; std::string res;
@ -35,7 +35,7 @@ std::string ToYAMLString(const T& dna) {
} }
template <class T> template <class T>
bool FromYAMLString(T& dna, std::string_view str) { inline bool FromYAMLString(T& dna, std::string_view str) {
YAMLStdStringViewReaderState reader(str); YAMLStdStringViewReaderState reader(str);
YAMLDocReader docReader; YAMLDocReader docReader;
yaml_parser_set_input(docReader.getParser(), (yaml_read_handler_t*)YAMLStdStringReader, &reader); yaml_parser_set_input(docReader.getParser(), (yaml_read_handler_t*)YAMLStdStringReader, &reader);
@ -46,7 +46,7 @@ bool FromYAMLString(T& dna, std::string_view str) {
} }
template <class DNASubtype> template <class DNASubtype>
bool ValidateFromYAMLString(std::string_view str) { inline bool ValidateFromYAMLString(std::string_view str) {
YAMLStdStringViewReaderState reader(str); YAMLStdStringViewReaderState reader(str);
YAMLDocReader docReader; YAMLDocReader docReader;
yaml_parser_set_input(docReader.getParser(), (yaml_read_handler_t*)YAMLStdStringReader, &reader); yaml_parser_set_input(docReader.getParser(), (yaml_read_handler_t*)YAMLStdStringReader, &reader);
@ -55,7 +55,7 @@ bool ValidateFromYAMLString(std::string_view str) {
} }
template <class T> template <class T>
bool ToYAMLStream(const T& dna, athena::io::IStreamWriter& fout) { inline bool ToYAMLStream(const T& dna, athena::io::IStreamWriter& fout) {
YAMLDocWriter docWriter(__GetDNAName(dna)); YAMLDocWriter docWriter(__GetDNAName(dna));
yaml_emitter_set_unicode(docWriter.getEmitter(), true); yaml_emitter_set_unicode(docWriter.getEmitter(), true);
@ -66,7 +66,8 @@ bool ToYAMLStream(const T& dna, athena::io::IStreamWriter& fout) {
} }
template <class T> template <class T>
bool ToYAMLStream(const T& dna, athena::io::IStreamWriter& fout, void (T::*fn)(YAMLDocWriter& out) const) { inline bool ToYAMLStream(const T& dna, athena::io::IStreamWriter& fout,
void (T::*fn)(YAMLDocWriter& out) const) {
YAMLDocWriter docWriter(__GetDNAName(dna)); YAMLDocWriter docWriter(__GetDNAName(dna));
yaml_emitter_set_unicode(docWriter.getEmitter(), true); yaml_emitter_set_unicode(docWriter.getEmitter(), true);
@ -77,7 +78,7 @@ bool ToYAMLStream(const T& dna, athena::io::IStreamWriter& fout, void (T::*fn)(Y
} }
template <class T> template <class T>
bool FromYAMLStream(T& dna, athena::io::IStreamReader& fin) { inline bool FromYAMLStream(T& dna, athena::io::IStreamReader& fin) {
YAMLDocReader docReader; YAMLDocReader docReader;
if (!docReader.parse(&fin)) if (!docReader.parse(&fin))
return false; return false;
@ -86,7 +87,7 @@ bool FromYAMLStream(T& dna, athena::io::IStreamReader& fin) {
} }
template <class T> template <class T>
bool FromYAMLStream(T& dna, athena::io::IStreamReader& fin, void (T::*fn)(YAMLDocReader& in)) { inline bool FromYAMLStream(T& dna, athena::io::IStreamReader& fin, void (T::*fn)(YAMLDocReader& in)) {
YAMLDocReader docReader; YAMLDocReader docReader;
if (!docReader.parse(&fin)) if (!docReader.parse(&fin))
return false; return false;
@ -95,7 +96,7 @@ bool FromYAMLStream(T& dna, athena::io::IStreamReader& fin, void (T::*fn)(YAMLDo
} }
template <class T, typename NameT> template <class T, typename NameT>
bool MergeToYAMLFile(const T& dna, const NameT& filename) { inline bool MergeToYAMLFile(const T& dna, const NameT& filename) {
athena::io::FileReader r(filename); athena::io::FileReader r(filename);
YAMLDocWriter docWriter(__GetDNAName(dna), r.isOpen() ? &r : nullptr); YAMLDocWriter docWriter(__GetDNAName(dna), r.isOpen() ? &r : nullptr);
r.close(); r.close();
@ -108,7 +109,7 @@ bool MergeToYAMLFile(const T& dna, const NameT& filename) {
} }
template <class DNASubtype> template <class DNASubtype>
bool ValidateFromYAMLStream(athena::io::IStreamReader& fin) { inline bool ValidateFromYAMLStream(athena::io::IStreamReader& fin) {
YAMLDocReader reader; YAMLDocReader reader;
atUint64 pos = fin.position(); atUint64 pos = fin.position();
yaml_parser_set_input(reader.getParser(), (yaml_read_handler_t*)YAMLAthenaReader, &fin); yaml_parser_set_input(reader.getParser(), (yaml_read_handler_t*)YAMLAthenaReader, &fin);

2
include/athena/Dir.hpp
View File

@ -14,7 +14,7 @@ public:
explicit Dir(std::string_view path); explicit Dir(std::string_view path);
std::string absolutePath() const; std::string absolutePath() const;
static std::string absolutePath(std::string_view path) { return Dir(path).absolutePath(); } static inline std::string absolutePath(std::string_view path) { return Dir(path).absolutePath(); }
bool isDir() const; bool isDir() const;
static bool isDir(std::string_view dir) { return Dir(dir).isDir(); } static bool isDir(std::string_view dir) { return Dir(dir).isDir(); }

20
include/athena/FileInfo.hpp
View File

@ -10,33 +10,33 @@ public:
explicit FileInfo(std::string_view path = {}); explicit FileInfo(std::string_view path = {});
std::string absolutePath() const; std::string absolutePath() const;
static std::string absolutePath(std::string_view lnk) { return FileInfo(lnk).absolutePath(); } static inline std::string absolutePath(std::string_view lnk) { return FileInfo(lnk).absolutePath(); }
std::string absoluteFilePath() const; std::string absoluteFilePath() const;
static std::string absoluteFilePath(std::string_view path) { return FileInfo(path).absoluteFilePath(); } static inline std::string absoluteFilePath(std::string_view path) { return FileInfo(path).absoluteFilePath(); }
std::string filename() const; std::string filename() const;
static std::string filename(std::string_view path) { return FileInfo(path).filename(); } static inline std::string filename(std::string_view path) { return FileInfo(path).filename(); }
std::string path() const { return m_path; } std::string path() const { return m_path; }
static std::string path(std::string_view path) { return FileInfo(path).path(); } static inline std::string path(std::string_view path) { return FileInfo(path).path(); }
std::string extension() const; std::string extension() const;
static std::string extension(std::string_view path) { return FileInfo(path).extension(); } static inline std::string extension(std::string_view path) { return FileInfo(path).extension(); }
atUint64 size() const; atUint64 size() const;
static atUint64 size(std::string_view path) { return FileInfo(path).size(); } static inline atUint64 size(std::string_view path) { return FileInfo(path).size(); }
bool exists() const; bool exists() const;
static bool exists(std::string_view path) { return FileInfo(path).exists(); } static inline bool exists(std::string_view path) { return FileInfo(path).exists(); }
bool isLink() const; bool isLink() const;
static bool isLink(std::string_view lnk) { return FileInfo(lnk).isLink(); } static inline bool isLink(std::string_view lnk) { return FileInfo(lnk).isLink(); }
bool isFile() const; bool isFile() const;
static bool isFile(std::string_view path) { return FileInfo(path).isFile(); } static inline bool isFile(std::string_view path) { return FileInfo(path).isFile(); }
bool touch() const; bool touch() const;
static bool touch(std::string_view path) { return FileInfo(path).touch(); } static inline bool touch(std::string_view path) { return FileInfo(path).touch(); }
private: private:
std::string m_path; std::string m_path;

16
include/athena/FileReader.hpp
View File

@ -18,9 +18,9 @@ class FileReader : public IStreamReader {
public: public:
FileReader(std::string_view filename, atInt32 cacheSize = (32 * 1024), bool globalErr = true); FileReader(std::string_view filename, atInt32 cacheSize = (32 * 1024), bool globalErr = true);
FileReader(std::wstring_view filename, atInt32 cacheSize = (32 * 1024), bool globalErr = true); FileReader(std::wstring_view filename, atInt32 cacheSize = (32 * 1024), bool globalErr = true);
~FileReader() override; virtual ~FileReader();
std::string filename() const { inline std::string filename() const {
#if _WIN32 #if _WIN32
return utility::wideToUtf8(m_filename); return utility::wideToUtf8(m_filename);
#else #else
@ -28,7 +28,7 @@ public:
#endif #endif
} }
std::wstring wfilename() const { inline std::wstring wfilename() const {
#if _WIN32 #if _WIN32
return m_filename; return m_filename;
#else #else
@ -38,12 +38,12 @@ public:
void open(); void open();
void close(); void close();
bool isOpen() const { return m_fileHandle != 0; } inline bool isOpen() const { return m_fileHandle != 0; }
bool save(); bool save();
void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current) override; void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current);
atUint64 position() const override; atUint64 position() const;
atUint64 length() const override; atUint64 length() const;
atUint64 readUBytesToBuf(void* buf, atUint64 len) override; atUint64 readUBytesToBuf(void* buf, atUint64 len);
void setCacheSize(const atInt32 blockSize); void setCacheSize(const atInt32 blockSize);

26
include/athena/FileWriter.hpp
View File

@ -15,16 +15,16 @@ class FileWriter : public IStreamWriter {
public: public:
FileWriter(std::string_view filename, bool overwrite = true, bool globalErr = true); FileWriter(std::string_view filename, bool overwrite = true, bool globalErr = true);
FileWriter(std::wstring_view filename, bool overwrite = true, bool globalErr = true); FileWriter(std::wstring_view filename, bool overwrite = true, bool globalErr = true);
~FileWriter() override; virtual ~FileWriter();
std::string filename() const { inline std::string filename() const {
#if _WIN32 #if _WIN32
return utility::wideToUtf8(m_filename); return utility::wideToUtf8(m_filename);
#else #else
return m_filename; return m_filename;
#endif #endif
} }
std::wstring wfilename() const { inline std::wstring wfilename() const {
#if _WIN32 #if _WIN32
return m_filename; return m_filename;
#else #else
@ -34,11 +34,11 @@ public:
void open(bool overwrite = true); void open(bool overwrite = true);
void close(); void close();
bool isOpen() const { return m_fileHandle != 0; } inline bool isOpen() const { return m_fileHandle != 0; }
void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current) override; void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current);
atUint64 position() const override; atUint64 position() const;
atUint64 length() const override; atUint64 length() const;
void writeUBytes(const atUint8* data, atUint64 len) override; void writeUBytes(const atUint8* data, atUint64 len);
#if _WIN32 #if _WIN32
using HandleType = HANDLE; using HandleType = HANDLE;
@ -99,12 +99,12 @@ public:
m_position = 0; m_position = 0;
} }
atUint64 position() const override { return m_position; } inline atUint64 position() const { return m_position; }
atUint64 length() const override { return m_deferredBuffer.size(); } inline atUint64 length() const { return m_deferredBuffer.size(); }
void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current) override; void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current);
void writeUBytes(const atUint8* data, atUint64 len) override; void writeUBytes(const atUint8* data, atUint64 len);
~TransactionalFileWriter() override { flush(); } ~TransactionalFileWriter() { flush(); }
}; };
} // namespace athena::io } // namespace athena::io

11
include/athena/Global.hpp
View File

@ -134,15 +134,16 @@ template <Endian DNAE>
struct DNAV; struct DNAV;
template <class T> template <class T>
using __IsDNARecord = std::disjunction<std::is_base_of<DNA<Endian::Big>, T>, std::is_base_of<DNA<Endian::Little>, T>>; using __IsDNARecord =
typename std::disjunction<std::is_base_of<DNA<Endian::Big>, T>, std::is_base_of<DNA<Endian::Little>, T>>;
template <class T> template <class T>
constexpr bool __IsDNARecord_v = __IsDNARecord<T>::value; inline constexpr bool __IsDNARecord_v = __IsDNARecord<T>::value;
template <class T> template <class T>
using __IsDNAVRecord = using __IsDNAVRecord =
std::disjunction<std::is_base_of<DNAV<Endian::Big>, T>, std::is_base_of<DNAV<Endian::Little>, T>>; typename std::disjunction<std::is_base_of<DNAV<Endian::Big>, T>, std::is_base_of<DNAV<Endian::Little>, T>>;
template <class T> template <class T>
constexpr bool __IsDNAVRecord_v = __IsDNAVRecord<T>::value; inline constexpr bool __IsDNAVRecord_v = __IsDNAVRecord<T>::value;
} // namespace io } // namespace io
} // namespace athena } // namespace athena
@ -162,7 +163,7 @@ std::ostream& operator<<(std::ostream& os, const athena::Endian& endian);
template <typename First, typename... Rest> template <typename First, typename... Rest>
constexpr auto __FIRST_ARG__(First first, Rest...) { return first; } constexpr auto __FIRST_ARG__(First first, Rest...) { return first; }
template <typename S, typename... Args> template <typename S, typename... Args>
auto __make_args_checked__(const S& format_str, Args&&... args) { inline auto __make_args_checked__(const S& format_str, Args&&... args) {
return fmt::internal::make_args_checked<Args...>(format_str, std::forward<Args>(args)...); return fmt::internal::make_args_checked<Args...>(format_str, std::forward<Args>(args)...);
} }

149
include/athena/IStreamReader.hpp
View File

@ -15,14 +15,14 @@ namespace athena::io {
*/ */
class IStreamReader : public IStream { class IStreamReader : public IStream {
public: public:
~IStreamReader() override = default; virtual ~IStreamReader() = default;
/** @brief Sets the buffers position relative to the specified position.<br /> /** @brief Sets the buffers position relative to the specified position.<br />
* It seeks relative to the current position by default. * It seeks relative to the current position by default.
* @param position where in the buffer to seek * @param position where in the buffer to seek
* @param origin The Origin to seek relative to * @param origin The Origin to seek relative to
*/ */
void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current) override = 0; virtual void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current) = 0;
/** @brief Sets the buffer's position relative to the next 64-byte aligned position.<br /> /** @brief Sets the buffer's position relative to the next 64-byte aligned position.<br />
*/ */
@ -44,19 +44,19 @@ public:
* *
* @return True if at end; False otherwise. * @return True if at end; False otherwise.
*/ */
bool atEnd() const override { return position() >= length(); } bool atEnd() const { return position() >= length(); }
/** @brief Returns the current position in the stream. /** @brief Returns the current position in the stream.
* *
* @return The current position in the stream. * @return The current position in the stream.
*/ */
atUint64 position() const override = 0; virtual atUint64 position() const = 0;
/** @brief Returns the length of the file. /** @brief Returns the length of the file.
* *
* @return True length of the file. * @return True length of the file.
*/ */
atUint64 length() const override = 0; virtual atUint64 length() const = 0;
/** @brief Reads a byte at the current position and advances the current position /** @brief Reads a byte at the current position and advances the current position
* *
@ -68,15 +68,15 @@ public:
return val; return val;
} }
template <class T> template <class T>
atInt8 readVal(std::enable_if_t<std::is_same_v<T, atInt8>>* = nullptr) { atInt8 readVal(typename std::enable_if<std::is_same<T, atInt8>::value>::type* = 0) {
return readByte(); return readByte();
} }
template <class T> template <class T>
atInt8 readValLittle(std::enable_if_t<std::is_same_v<T, atInt8>>* = nullptr) { atInt8 readValLittle(typename std::enable_if<std::is_same<T, atInt8>::value>::type* = 0) {
return readByte(); return readByte();
} }
template <class T> template <class T>
atInt8 readValBig(std::enable_if_t<std::is_same_v<T, atInt8>>* = nullptr) { atInt8 readValBig(typename std::enable_if<std::is_same<T, atInt8>::value>::type* = 0) {
return readByte(); return readByte();
} }
@ -86,15 +86,15 @@ public:
*/ */
atUint8 readUByte() { return readByte(); } atUint8 readUByte() { return readByte(); }
template <class T> template <class T>
atUint8 readVal(std::enable_if_t<std::is_same_v<T, atUint8>>* = nullptr) { atUint8 readVal(typename std::enable_if<std::is_same<T, atUint8>::value>::type* = 0) {
return readUByte(); return readUByte();
} }
template <class T> template <class T>
atUint8 readValLittle(std::enable_if_t<std::is_same_v<T, atUint8>>* = nullptr) { atUint8 readValLittle(typename std::enable_if<std::is_same<T, atUint8>::value>::type* = 0) {
return readUByte(); return readUByte();
} }
template <class T> template <class T>
atUint8 readValBig(std::enable_if_t<std::is_same_v<T, atUint8>>* = nullptr) { atUint8 readValBig(typename std::enable_if<std::is_same<T, atUint8>::value>::type* = 0) {
return readUByte(); return readUByte();
} }
@ -144,7 +144,7 @@ public:
return m_endian == Big ? utility::BigInt16(val) : utility::LittleInt16(val); return m_endian == Big ? utility::BigInt16(val) : utility::LittleInt16(val);
} }
template <class T> template <class T>
atInt16 readVal(std::enable_if_t<std::is_same_v<T, atInt16>>* = nullptr) { atInt16 readVal(typename std::enable_if<std::is_same<T, atInt16>::value>::type* = 0) {
return readInt16(); return readInt16();
} }
@ -159,7 +159,7 @@ public:
return utility::LittleInt16(val); return utility::LittleInt16(val);
} }
template <class T> template <class T>
atInt16 readValLittle(std::enable_if_t<std::is_same_v<T, atInt16>>* = nullptr) { atInt16 readValLittle(typename std::enable_if<std::is_same<T, atInt16>::value>::type* = 0) {
return readInt16Little(); return readInt16Little();
} }
@ -174,7 +174,7 @@ public:
return utility::BigInt16(val); return utility::BigInt16(val);
} }
template <class T> template <class T>
atInt16 readValBig(std::enable_if_t<std::is_same_v<T, atInt16>>* = nullptr) { atInt16 readValBig(typename std::enable_if<std::is_same<T, atInt16>::value>::type* = 0) {
return readInt16Big(); return readInt16Big();
} }
@ -185,7 +185,7 @@ public:
*/ */
atUint16 readUint16() { return readInt16(); } atUint16 readUint16() { return readInt16(); }
template <class T> template <class T>
atUint16 readVal(std::enable_if_t<std::is_same_v<T, atUint16>>* = 0) { atUint16 readVal(typename std::enable_if<std::is_same<T, atUint16>::value>::type* = 0) {
return readUint16(); return readUint16();
} }
@ -200,7 +200,7 @@ public:
return utility::LittleUint16(val); return utility::LittleUint16(val);
} }
template <class T> template <class T>
atUint16 readValLittle(std::enable_if_t<std::is_same_v<T, atUint16>>* = nullptr) { atUint16 readValLittle(typename std::enable_if<std::is_same<T, atUint16>::value>::type* = 0) {
return readUint16Little(); return readUint16Little();
} }
@ -215,7 +215,7 @@ public:
return utility::BigUint16(val); return utility::BigUint16(val);
} }
template <class T> template <class T>
atUint16 readValBig(std::enable_if_t<std::is_same_v<T, atUint16>>* = nullptr) { atUint16 readValBig(typename std::enable_if<std::is_same<T, atUint16>::value>::type* = 0) {
return readUint16Big(); return readUint16Big();
} }
@ -230,7 +230,7 @@ public:
return m_endian == Big ? utility::BigInt32(val) : utility::LittleInt32(val); return m_endian == Big ? utility::BigInt32(val) : utility::LittleInt32(val);
} }
template <class T> template <class T>
atInt32 readVal(std::enable_if_t<std::is_same_v<T, atInt32>>* = nullptr) { atInt32 readVal(typename std::enable_if<std::is_same<T, atInt32>::value>::type* = 0) {
return readInt32(); return readInt32();
} }
@ -245,7 +245,7 @@ public:
return utility::LittleInt32(val); return utility::LittleInt32(val);
} }
template <class T> template <class T>
atInt32 readValLittle(std::enable_if_t<std::is_same_v<T, atInt32>>* = nullptr) { atInt32 readValLittle(typename std::enable_if<std::is_same<T, atInt32>::value>::type* = 0) {
return readInt32Little(); return readInt32Little();
} }
@ -260,7 +260,7 @@ public:
return utility::BigInt32(val); return utility::BigInt32(val);
} }
template <class T> template <class T>
atInt32 readValBig(std::enable_if_t<std::is_same_v<T, atInt32>>* = nullptr) { atInt32 readValBig(typename std::enable_if<std::is_same<T, atInt32>::value>::type* = 0) {
return readInt32Big(); return readInt32Big();
} }
@ -271,7 +271,7 @@ public:
*/ */
atUint32 readUint32() { return readInt32(); } atUint32 readUint32() { return readInt32(); }
template <class T> template <class T>
atUint32 readVal(std::enable_if_t<std::is_same_v<T, atUint32>>* = nullptr) { atUint32 readVal(typename std::enable_if<std::is_same<T, atUint32>::value>::type* = 0) {
return readUint32(); return readUint32();
} }
@ -286,7 +286,7 @@ public:
return utility::LittleUint32(val); return utility::LittleUint32(val);
} }
template <class T> template <class T>
atInt32 readValLittle(std::enable_if_t<std::is_same_v<T, atUint32>>* = nullptr) { atInt32 readValLittle(typename std::enable_if<std::is_same<T, atUint32>::value>::type* = 0) {
return readUint32Little(); return readUint32Little();
} }
@ -301,7 +301,7 @@ public:
return utility::BigUint32(val); return utility::BigUint32(val);
} }
template <class T> template <class T>
atUint32 readValBig(std::enable_if_t<std::is_same_v<T, atUint32>>* = nullptr) { atUint32 readValBig(typename std::enable_if<std::is_same<T, atUint32>::value>::type* = 0) {
return readUint32Big(); return readUint32Big();
} }
@ -316,7 +316,7 @@ public:
return m_endian == Big ? utility::BigInt64(val) : utility::LittleInt64(val); return m_endian == Big ? utility::BigInt64(val) : utility::LittleInt64(val);
} }
template <class T> template <class T>
atInt64 readVal(std::enable_if_t<std::is_same_v<T, atInt64>>* = nullptr) { atInt64 readVal(typename std::enable_if<std::is_same<T, atInt64>::value>::type* = 0) {
return readInt64(); return readInt64();
} }
@ -331,7 +331,7 @@ public:
return utility::LittleInt64(val); return utility::LittleInt64(val);
} }
template <class T> template <class T>
atInt64 readValLittle(std::enable_if_t<std::is_same_v<T, atInt64>>* = nullptr) { atInt64 readValLittle(typename std::enable_if<std::is_same<T, atInt64>::value>::type* = 0) {
return readInt64Little(); return readInt64Little();
} }
@ -346,7 +346,7 @@ public:
return utility::BigInt64(val); return utility::BigInt64(val);
} }
template <class T> template <class T>
atInt64 readValBig(std::enable_if_t<std::is_same_v<T, atInt64>>* = nullptr) { atInt64 readValBig(typename std::enable_if<std::is_same<T, atInt64>::value>::type* = 0) {
return readInt64Big(); return readInt64Big();
} }
@ -357,7 +357,7 @@ public:
*/ */
atUint64 readUint64() { return readInt64(); } atUint64 readUint64() { return readInt64(); }
template <class T> template <class T>
atUint64 readVal(std::enable_if_t<std::is_same_v<T, atUint64>>* = nullptr) { atUint64 readVal(typename std::enable_if<std::is_same<T, atUint64>::value>::type* = 0) {
return readUint64(); return readUint64();
} }
@ -372,7 +372,7 @@ public:
return utility::LittleUint64(val); return utility::LittleUint64(val);
} }
template <class T> template <class T>
atUint64 readValLittle(std::enable_if_t<std::is_same_v<T, atUint64>>* = nullptr) { atUint64 readValLittle(typename std::enable_if<std::is_same<T, atUint64>::value>::type* = 0) {
return readUint64Little(); return readUint64Little();
} }
@ -387,7 +387,7 @@ public:
return utility::BigUint64(val); return utility::BigUint64(val);
} }
template <class T> template <class T>
atUint64 readValBig(std::enable_if_t<std::is_same_v<T, atUint64>>* = nullptr) { atUint64 readValBig(typename std::enable_if<std::is_same<T, atUint64>::value>::type* = 0) {
return readUint64Big(); return readUint64Big();
} }
@ -402,7 +402,7 @@ public:
return m_endian == Big ? utility::BigFloat(val) : utility::LittleFloat(val); return m_endian == Big ? utility::BigFloat(val) : utility::LittleFloat(val);
} }
template <class T> template <class T>
float readVal(std::enable_if_t<std::is_same_v<T, float>>* = nullptr) { float readVal(typename std::enable_if<std::is_same<T, float>::value>::type* = 0) {
return readFloat(); return readFloat();
} }
@ -417,7 +417,7 @@ public:
return utility::LittleFloat(val); return utility::LittleFloat(val);
} }
template <class T> template <class T>
float readValLittle(std::enable_if_t<std::is_same_v<T, float>>* = nullptr) { float readValLittle(typename std::enable_if<std::is_same<T, float>::value>::type* = 0) {
return readFloatLittle(); return readFloatLittle();
} }
@ -432,7 +432,7 @@ public:
return utility::BigFloat(val); return utility::BigFloat(val);
} }
template <class T> template <class T>
float readValBig(std::enable_if_t<std::is_same_v<T, float>>* = nullptr) { float readValBig(typename std::enable_if<std::is_same<T, float>::value>::type* = 0) {
return readFloatBig(); return readFloatBig();
} }
@ -447,7 +447,7 @@ public:
return m_endian == Big ? utility::BigDouble(val) : utility::LittleDouble(val); return m_endian == Big ? utility::BigDouble(val) : utility::LittleDouble(val);
} }
template <class T> template <class T>
double readVal(std::enable_if_t<std::is_same_v<T, double>>* = nullptr) { double readVal(typename std::enable_if<std::is_same<T, double>::value>::type* = 0) {
return readDouble(); return readDouble();
} }
@ -462,7 +462,7 @@ public:
return utility::LittleDouble(val); return utility::LittleDouble(val);
} }
template <class T> template <class T>
double readValLittle(std::enable_if_t<std::is_same_v<T, double>>* = nullptr) { double readValLittle(typename std::enable_if<std::is_same<T, double>::value>::type* = 0) {
return readDoubleLittle(); return readDoubleLittle();
} }
@ -477,7 +477,7 @@ public:
return utility::BigDouble(val); return utility::BigDouble(val);
} }
template <class T> template <class T>
double readValBig(std::enable_if_t<std::is_same_v<T, double>>* = nullptr) { double readValBig(typename std::enable_if<std::is_same<T, double>::value>::type* = 0) {
return readDoubleBig(); return readDoubleBig();
} }
@ -491,15 +491,15 @@ public:
return val != 0; return val != 0;
} }
template <class T> template <class T>
bool readVal(std::enable_if_t<std::is_same_v<T, bool>>* = nullptr) { bool readVal(typename std::enable_if<std::is_same<T, bool>::value>::type* = 0) {
return readBool(); return readBool();
} }
template <class T> template <class T>
bool readValLittle(std::enable_if_t<std::is_same_v<T, bool>>* = nullptr) { bool readValLittle(typename std::enable_if<std::is_same<T, bool>::value>::type* = 0) {
return readBool(); return readBool();
} }
template <class T> template <class T>
bool readValBig(std::enable_if_t<std::is_same_v<T, bool>>* = nullptr) { bool readValBig(typename std::enable_if<std::is_same<T, bool>::value>::type* = 0) {
return readBool(); return readBool();
} }
@ -525,7 +525,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec2f readVal(std::enable_if_t<std::is_same_v<T, atVec2f>>* = nullptr) { atVec2f readVal(typename std::enable_if<std::is_same<T, atVec2f>::value>::type* = 0) {
return readVec2f(); return readVec2f();
} }
@ -546,7 +546,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec2f readValLittle(std::enable_if_t<std::is_same_v<T, atVec2f>>* = nullptr) { atVec2f readValLittle(typename std::enable_if<std::is_same<T, atVec2f>::value>::type* = 0) {
return readVec2fLittle(); return readVec2fLittle();
} }
@ -567,7 +567,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec2f readValBig(std::enable_if_t<std::is_same_v<T, atVec2f>>* = nullptr) { atVec2f readValBig(typename std::enable_if<std::is_same<T, atVec2f>::value>::type* = 0) {
return readVec2fBig(); return readVec2fBig();
} }
@ -594,7 +594,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec3f readVal(std::enable_if_t<std::is_same_v<T, atVec3f>>* = nullptr) { atVec3f readVal(typename std::enable_if<std::is_same<T, atVec3f>::value>::type* = 0) {
return readVec3f(); return readVec3f();
} }
@ -615,7 +615,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec3f readValLittle(std::enable_if_t<std::is_same_v<T, atVec3f>>* = nullptr) { atVec3f readValLittle(typename std::enable_if<std::is_same<T, atVec3f>::value>::type* = 0) {
return readVec3fLittle(); return readVec3fLittle();
} }
@ -636,7 +636,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec3f readValBig(std::enable_if_t<std::is_same_v<T, atVec3f>>* = nullptr) { atVec3f readValBig(typename std::enable_if<std::is_same<T, atVec3f>::value>::type* = 0) {
return readVec3fBig(); return readVec3fBig();
} }
@ -664,7 +664,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec4f readVal(std::enable_if_t<std::is_same_v<T, atVec4f>>* = nullptr) { atVec4f readVal(typename std::enable_if<std::is_same<T, atVec4f>::value>::type* = 0) {
return readVec4f(); return readVec4f();
} }
@ -685,7 +685,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec4f readValLittle(std::enable_if_t<std::is_same_v<T, atVec4f>>* = nullptr) { atVec4f readValLittle(typename std::enable_if<std::is_same<T, atVec4f>::value>::type* = 0) {
return readVec4fLittle(); return readVec4fLittle();
} }
@ -706,7 +706,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec4f readValBig(std::enable_if_t<std::is_same_v<T, atVec4f>>* = nullptr) { atVec4f readValBig(typename std::enable_if<std::is_same<T, atVec4f>::value>::type* = 0) {
return readVec4fBig(); return readVec4fBig();
} }
@ -732,7 +732,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec2d readVal(std::enable_if_t<std::is_same_v<T, atVec2d>>* = nullptr) { atVec2d readVal(typename std::enable_if<std::is_same<T, atVec2d>::value>::type* = 0) {
return readVec2d(); return readVec2d();
} }
@ -753,7 +753,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec2d readValLittle(std::enable_if_t<std::is_same_v<T, atVec2d>>* = nullptr) { atVec2d readValLittle(typename std::enable_if<std::is_same<T, atVec2d>::value>::type* = 0) {
return readVec2dLittle(); return readVec2dLittle();
} }
@ -774,7 +774,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec2d readValBig(std::enable_if_t<std::is_same_v<T, atVec2d>>* = nullptr) { atVec2d readValBig(typename std::enable_if<std::is_same<T, atVec2d>::value>::type* = 0) {
return readVec2dBig(); return readVec2dBig();
} }
@ -801,7 +801,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec3d readVal(std::enable_if_t<std::is_same_v<T, atVec3d>>* = nullptr) { atVec3d readVal(typename std::enable_if<std::is_same<T, atVec3d>::value>::type* = 0) {
return readVec3d(); return readVec3d();
} }
@ -822,7 +822,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec3d readValLittle(std::enable_if_t<std::is_same_v<T, atVec3d>>* = nullptr) { atVec3d readValLittle(typename std::enable_if<std::is_same<T, atVec3d>::value>::type* = 0) {
return readVec3dLittle(); return readVec3dLittle();
} }
@ -843,7 +843,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec3d readValBig(std::enable_if_t<std::is_same_v<T, atVec3d>>* = nullptr) { atVec3d readValBig(typename std::enable_if<std::is_same<T, atVec3d>::value>::type* = 0) {
return readVec3dBig(); return readVec3dBig();
} }
@ -871,7 +871,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec4d readVal(std::enable_if_t<std::is_same_v<T, atVec4d>>* = nullptr) { atVec4d readVal(typename std::enable_if<std::is_same<T, atVec4d>::value>::type* = 0) {
return readVec4d(); return readVec4d();
} }
@ -892,7 +892,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec4d readValLittle(std::enable_if_t<std::is_same_v<T, atVec4d>>* = nullptr) { atVec4d readValLittle(typename std::enable_if<std::is_same<T, atVec4d>::value>::type* = 0) {
return readVec4dLittle(); return readVec4dLittle();
} }
@ -913,7 +913,7 @@ public:
return s; return s;
} }
template <class T> template <class T>
atVec4d readValBig(std::enable_if_t<std::is_same_v<T, atVec4d>>* = nullptr) { atVec4d readValBig(typename std::enable_if<std::is_same<T, atVec4d>::value>::type* = 0) {
return readVec4dBig(); return readVec4dBig();
} }
@ -944,7 +944,7 @@ public:
return ret; return ret;
} }
template <class T> template <class T>
std::string readVal(std::enable_if_t<std::is_same_v<T, std::string>>* = nullptr) { std::string readVal(typename std::enable_if<std::is_same<T, std::string>::value>::type* = 0) {
return readString(); return readString();
} }
@ -976,7 +976,7 @@ public:
return ret; return ret;
} }
template <class T> template <class T>
std::wstring readVal(std::enable_if_t<std::is_same_v<T, std::wstring>>* = nullptr) { std::wstring readVal(typename std::enable_if<std::is_same<T, std::wstring>::value>::type* = 0) {
return readWString(); return readWString();
} }
@ -1009,7 +1009,7 @@ public:
return ret; return ret;
} }
template <class T> template <class T>
std::wstring readValLittle(std::enable_if_t<std::is_same_v<T, std::wstring>>* = nullptr) { std::wstring readValLittle(typename std::enable_if<std::is_same<T, std::wstring>::value>::type* = 0) {
return readWStringLittle(); return readWStringLittle();
} }
@ -1041,7 +1041,7 @@ public:
return ret; return ret;
} }
template <class T> template <class T>
std::wstring readValBig(std::enable_if_t<std::is_same_v<T, std::wstring>>* = nullptr) { std::wstring readValBig(typename std::enable_if<std::is_same<T, std::wstring>::value>::type* = 0) {
return readWStringBig(); return readWStringBig();
} }
@ -1073,7 +1073,7 @@ public:
return ret; return ret;
} }
template <class T> template <class T>
std::u16string readValBig(std::enable_if_t<std::is_same_v<T, std::u16string>>* = nullptr) { std::u16string readValBig(typename std::enable_if<std::is_same<T, std::u16string>::value>::type* = 0) {
return readU16StringBig(); return readU16StringBig();
} }
@ -1105,7 +1105,7 @@ public:
return ret; return ret;
} }
template <class T> template <class T>
std::u32string readValBig(std::enable_if_t<std::is_same_v<T, std::u32string>>* = nullptr) { std::u32string readValBig(typename std::enable_if<std::is_same<T, std::u32string>::value>::type* = 0) {
return readU32StringBig(); return readU32StringBig();
} }
@ -1119,8 +1119,8 @@ public:
template <class T> template <class T>
void void
enumerate(std::vector<T>& vector, size_t count, enumerate(std::vector<T>& vector, size_t count,
std::enable_if<std::is_arithmetic_v<T> || std::is_same_v<T, atVec2f> || typename std::enable_if<std::is_arithmetic<T>::value || std::is_same<T, atVec2f>::value ||
std::is_same_v<T, atVec3f> || std::is_same_v<T, atVec4f>>* = nullptr) { std::is_same<T, atVec3f>::value || std::is_same<T, atVec4f>::value>::type* = 0) {
vector.clear(); vector.clear();
vector.reserve(count); vector.reserve(count);
for (size_t i = 0; i < count; ++i) for (size_t i = 0; i < count; ++i)
@ -1135,9 +1135,10 @@ public:
* Endianness is little * Endianness is little
*/ */
template <class T> template <class T>
void enumerateLittle(std::vector<T>& vector, size_t count, void enumerateLittle(
std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, atVec2f> || std::vector<T>& vector, size_t count,
std::is_same_v<T, atVec3f> || std::is_same_v<T, atVec4f>>* = nullptr) { typename std::enable_if<std::is_arithmetic<T>::value || std::is_same<T, atVec2f>::value ||
std::is_same<T, atVec3f>::value || std::is_same<T, atVec4f>::value>::type* = 0) {
vector.clear(); vector.clear();
vector.reserve(count); vector.reserve(count);
for (size_t i = 0; i < count; ++i) for (size_t i = 0; i < count; ++i)
@ -1152,9 +1153,10 @@ public:
* Endianness is big * Endianness is big
*/ */
template <class T> template <class T>
void enumerateBig(std::vector<T>& vector, size_t count, void
std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, atVec2f> || enumerateBig(std::vector<T>& vector, size_t count,
std::is_same_v<T, atVec3f> || std::is_same_v<T, atVec4f>>* = nullptr) { typename std::enable_if<std::is_arithmetic<T>::value || std::is_same<T, atVec2f>::value ||
std::is_same<T, atVec3f>::value || std::is_same<T, atVec4f>::value>::type* = 0) {
vector.clear(); vector.clear();
vector.reserve(count); vector.reserve(count);
for (size_t i = 0; i < count; ++i) for (size_t i = 0; i < count; ++i)
@ -1167,9 +1169,10 @@ public:
* @param count The number of elements to read into vector * @param count The number of elements to read into vector
*/ */
template <class T> template <class T>
void enumerate(std::vector<T>& vector, size_t count, void
std::enable_if_t<!std::is_arithmetic_v<T> && !std::is_same_v<T, atVec2f> && enumerate(std::vector<T>& vector, size_t count,
!std::is_same_v<T, atVec3f> && !std::is_same_v<T, atVec4f>>* = nullptr) { typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_same<T, atVec2f>::value &&
!std::is_same<T, atVec3f>::value && !std::is_same<T, atVec4f>::value>::type* = 0) {
vector.clear(); vector.clear();
vector.reserve(count); vector.reserve(count);
for (size_t i = 0; i < count; ++i) { for (size_t i = 0; i < count; ++i) {

38
include/athena/IStreamWriter.hpp
View File

@ -9,14 +9,14 @@
namespace athena::io { namespace athena::io {
class IStreamWriter : public IStream { class IStreamWriter : public IStream {
public: public:
~IStreamWriter() override = default; virtual ~IStreamWriter() = default;
/** @brief Sets the buffers position relative to the specified position.<br /> /** @brief Sets the buffers position relative to the specified position.<br />
* It seeks relative to the current position by default. * It seeks relative to the current position by default.
* @param position where in the buffer to seek * @param position where in the buffer to seek
* @param origin The location to seek relative to * @param origin The location to seek relative to
*/ */
void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current) override = 0; virtual void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current) = 0;
/** @brief Sets the buffers position relative to the next 32-byte aligned position.<br /> /** @brief Sets the buffers position relative to the next 32-byte aligned position.<br />
*/ */
@ -36,19 +36,19 @@ public:
* *
* @return True if at end; False otherwise. * @return True if at end; False otherwise.
*/ */
bool atEnd() const override { return position() >= length(); } bool atEnd() const { return position() >= length(); }
/** @brief Returns the current position in the stream. /** @brief Returns the current position in the stream.
* *
* @return The current position in the stream. * @return The current position in the stream.
*/ */
atUint64 position() const override = 0; virtual atUint64 position() const = 0;
/** @brief Returns whether or not the stream is at the end. /** @brief Returns whether or not the stream is at the end.
* *
* @return True if at end; False otherwise. * @return True if at end; False otherwise.
*/ */
atUint64 length() const override = 0; virtual atUint64 length() const = 0;
/** @brief Writes a byte at the current position and advances the position by one byte. /** @brief Writes a byte at the current position and advances the position by one byte.
* @param val The value to write * @param val The value to write
@ -989,9 +989,10 @@ public:
* Endianness is set with setEndian * Endianness is set with setEndian
*/ */
template <class T> template <class T>
void enumerate(const std::vector<T>& vector, void
std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, atVec2f> || std::is_same_v<T, atVec3f> || enumerate(const std::vector<T>& vector,
std::is_same_v<T, atVec4f>>* = nullptr) { typename std::enable_if<std::is_arithmetic<T>::value || std::is_same<T, atVec2f>::value ||
std::is_same<T, atVec3f>::value || std::is_same<T, atVec4f>::value>::type* = 0) {
for (const T& item : vector) for (const T& item : vector)
writeVal(item); writeVal(item);
} }
@ -1002,9 +1003,10 @@ public:
* Endianness is little * Endianness is little
*/ */
template <class T> template <class T>
void enumerateLittle(const std::vector<T>& vector, void enumerateLittle(
std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, atVec2f> || const std::vector<T>& vector,
std::is_same_v<T, atVec3f> || std::is_same_v<T, atVec4f>>* = nullptr) { typename std::enable_if<std::is_arithmetic<T>::value || std::is_same<T, atVec2f>::value ||
std::is_same<T, atVec3f>::value || std::is_same<T, atVec4f>::value>::type* = 0) {
for (const T& item : vector) for (const T& item : vector)
writeValLittle(item); writeValLittle(item);
} }
@ -1015,9 +1017,10 @@ public:
* Endianness is big * Endianness is big
*/ */
template <class T> template <class T>
void enumerateBig(const std::vector<T>& vector, void
std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, atVec2f> || enumerateBig(const std::vector<T>& vector,
std::is_same_v<T, atVec3f> || std::is_same_v<T, atVec4f>>* = nullptr) { typename std::enable_if<std::is_arithmetic<T>::value || std::is_same<T, atVec2f>::value ||
std::is_same<T, atVec3f>::value || std::is_same<T, atVec4f>::value>::type* = 0) {
for (const T& item : vector) for (const T& item : vector)
writeValBig(item); writeValBig(item);
} }
@ -1026,9 +1029,10 @@ public:
* @param vector The std::vector read from when writing data * @param vector The std::vector read from when writing data
*/ */
template <class T> template <class T>
void enumerate(const std::vector<T>& vector, void
std::enable_if_t<!std::is_arithmetic_v<T> && !std::is_same_v<T, atVec2f> && enumerate(const std::vector<T>& vector,
!std::is_same_v<T, atVec3f> && !std::is_same_v<T, atVec4f>>* = nullptr) { typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_same<T, atVec2f>::value &&
!std::is_same<T, atVec3f>::value && !std::is_same<T, atVec4f>::value>::type* = 0) {
for (const T& item : vector) for (const T& item : vector)
item.write(*this); item.write(*this);
} }

10
include/athena/MemoryReader.hpp
View File

@ -19,7 +19,7 @@ protected:
MemoryReader() = default; MemoryReader() = default;
public: public:
~MemoryReader() override; virtual ~MemoryReader();
/*! \brief This constructor references an existing buffer to read from. /*! \brief This constructor references an existing buffer to read from.
* *
@ -34,19 +34,19 @@ public:
* \param position where in the buffer to seek * \param position where in the buffer to seek
* \param origin The Origin to seek \sa SeekOrigin * \param origin The Origin to seek \sa SeekOrigin
*/ */
void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current) override; void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current);
/*! \brief Returns the current position in the stream. /*! \brief Returns the current position in the stream.
* *
* \return Int64 The current position in the stream. * \return Int64 The current position in the stream.
*/ */
atUint64 position() const override { return m_position; } inline atUint64 position() const { return m_position; }
/*! \brief Returns whether or not the stream is at the end. /*! \brief Returns whether or not the stream is at the end.
* *
* \return bool True if at end; False otherwise. * \return bool True if at end; False otherwise.
*/ */
atUint64 length() const override { return m_length; } inline atUint64 length() const { return m_length; }
/*! \brief Sets the buffer to the given one, deleting the current one.<br /> /*! \brief Sets the buffer to the given one, deleting the current one.<br />
* <b>BEWARE:</b> As this deletes the current buffer it WILL cause a loss of data * <b>BEWARE:</b> As this deletes the current buffer it WILL cause a loss of data
@ -74,7 +74,7 @@ public:
* \param len Length to read * \param len Length to read
* \return Number of bytes read * \return Number of bytes read
*/ */
atUint64 readUBytesToBuf(void* buf, atUint64 len) override; atUint64 readUBytesToBuf(void* buf, atUint64 len);
protected: protected:
const void* m_data = nullptr; const void* m_data = nullptr;

20
include/athena/MemoryWriter.hpp
View File

@ -17,7 +17,7 @@ namespace athena::io {
*/ */
class MemoryWriter : public IStreamWriter { class MemoryWriter : public IStreamWriter {
public: public:
~MemoryWriter() override; virtual ~MemoryWriter();
/*! @brief This constructor references an existing buffer to write to in-place. /*! @brief This constructor references an existing buffer to write to in-place.
* *
@ -31,21 +31,21 @@ public:
* @param position where in the buffer to seek * @param position where in the buffer to seek
* @param origin The Origin to seek @sa SeekOrigin * @param origin The Origin to seek @sa SeekOrigin
*/ */
void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current) override; void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current);
/*! @brief Returns the current position in the stream. /*! @brief Returns the current position in the stream.
* *
* @return Int64 The current position in the stream. * @return Int64 The current position in the stream.
*/ */
atUint64 position() const override { return m_position; } inline atUint64 position() const { return m_position; }
/*! @brief Returns the length of the stream. /*! @brief Returns the length of the stream.
* *
* @return Int64 The length of the stream. * @return Int64 The length of the stream.
*/ */
atUint64 length() const override { return m_length; } inline atUint64 length() const { return m_length; }
bool isOpen() const { return true; } inline bool isOpen() const { return true; }
/** @brief Sets the buffer to the given one, deleting the current one if it owns it.<br /> /** @brief Sets the buffer to the given one, deleting the current one if it owns it.<br />
* @param data The new buffer. * @param data The new buffer.
@ -65,12 +65,12 @@ public:
* *
* @param filepath The path to write to. * @param filepath The path to write to.
*/ */
void setFilepath(const std::string& filepath) { m_filepath = filepath; } inline void setFilepath(const std::string& filepath) { m_filepath = filepath; }
/*! @brief /*! @brief
* Returns the target file * Returns the target file
*/ */
std::string filepath() const { return m_filepath; } inline std::string filepath() const { return m_filepath; }
/*! @brief Saves the file to the specified file. /*! @brief Saves the file to the specified file.
* *
@ -85,7 +85,7 @@ public:
* @param data The buffer to write * @param data The buffer to write
* @param length The amount to write * @param length The amount to write
*/ */
void writeUBytes(const atUint8* data, atUint64 len) override; void writeUBytes(const atUint8* data, atUint64 len);
protected: protected:
MemoryWriter() {} MemoryWriter() {}
@ -116,7 +116,7 @@ public:
* @param position where in the buffer to seek * @param position where in the buffer to seek
* @param origin The Origin to seek @sa SeekOrigin * @param origin The Origin to seek @sa SeekOrigin
*/ */
void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current) override; void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current);
/*! @brief Sets the buffer to the given one, deleting the current one.<br /> /*! @brief Sets the buffer to the given one, deleting the current one.<br />
* <b>BEWARE:</b> As this deletes the current buffer it WILL cause a loss of data * <b>BEWARE:</b> As this deletes the current buffer it WILL cause a loss of data
@ -135,7 +135,7 @@ public:
* @param data The buffer to write * @param data The buffer to write
* @param length The amount to write * @param length The amount to write
*/ */
void writeUBytes(const atUint8* data, atUint64 len) override; void writeUBytes(const atUint8* data, atUint64 len);
protected: protected:
std::unique_ptr<atUint8[]> m_dataCopy; std::unique_ptr<atUint8[]> m_dataCopy;

4
include/athena/Utility.hpp
View File

@ -181,9 +181,9 @@ atUint64 rand64();
std::string join(const std::vector<std::string>& elems, std::string_view delims); std::string join(const std::vector<std::string>& elems, std::string_view delims);
void tolower(std::string& str); void tolower(std::string& str);
void toupper(std::string& str); void toupper(std::string& str);
bool parseBool(std::string_view boolean, bool* valid = nullptr); bool parseBool(std::string_view boolean, bool* valid = NULL);
int countChar(std::string_view str, char chr, int* lastOccur = nullptr); int countChar(std::string_view str, const char chr, int* lastOccur = NULL);
// trim from start // trim from start
std::string& ltrim(std::string& s); std::string& ltrim(std::string& s);

10
include/athena/VectorWriter.hpp
View File

@ -22,21 +22,21 @@ public:
* @param position where in the buffer to seek * @param position where in the buffer to seek
* @param origin The Origin to seek @sa SeekOrigin * @param origin The Origin to seek @sa SeekOrigin
*/ */
void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current) override; void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current);
/*! @brief Returns the current position in the stream. /*! @brief Returns the current position in the stream.
* *
* @return Int64 The current position in the stream. * @return Int64 The current position in the stream.
*/ */
atUint64 position() const override { return m_position; } inline atUint64 position() const { return m_position; }
/*! @brief Returns the length of the stream. /*! @brief Returns the length of the stream.
* *
* @return Int64 The length of the stream. * @return Int64 The length of the stream.
*/ */
atUint64 length() const override { return m_data.size(); } inline atUint64 length() const { return m_data.size(); }
bool isOpen() const { return true; } inline bool isOpen() const { return true; }
/*! @brief Obtains reference to underlying std::vector store */ /*! @brief Obtains reference to underlying std::vector store */
const std::vector<uint8_t>& data() const { return m_data; } const std::vector<uint8_t>& data() const { return m_data; }
@ -48,7 +48,7 @@ public:
* @param data The buffer to write * @param data The buffer to write
* @param length The amount to write * @param length The amount to write
*/ */
void writeUBytes(const atUint8* data, atUint64 len) override; void writeUBytes(const atUint8* data, atUint64 len);
protected: protected:
std::vector<uint8_t> m_data; std::vector<uint8_t> m_data;

4
include/athena/YAMLCommon.hpp
View File

@ -27,14 +27,14 @@ struct YAMLNode {
YAMLNode(yaml_node_type_t type) : m_type(type) {} YAMLNode(yaml_node_type_t type) : m_type(type) {}
const YAMLNode* findMapChild(std::string_view key) const { inline const YAMLNode* findMapChild(std::string_view key) const {
for (const auto& item : m_mapChildren) for (const auto& item : m_mapChildren)
if (!item.first.compare(key)) if (!item.first.compare(key))
return item.second.get(); return item.second.get();
return nullptr; return nullptr;
} }
void assignMapChild(std::string_view key, std::unique_ptr<YAMLNode>&& node) { inline void assignMapChild(std::string_view key, std::unique_ptr<YAMLNode>&& node) {
for (auto& item : m_mapChildren) for (auto& item : m_mapChildren)
if (!item.first.compare(key)) { if (!item.first.compare(key)) {
item.second = std::move(node); item.second = std::move(node);

19
include/athena/YAMLDocReader.hpp
View File

@ -19,15 +19,15 @@ public:
void reset(); void reset();
yaml_parser_t* getParser() { return &m_parser; } inline yaml_parser_t* getParser() { return &m_parser; }
bool parse(athena::io::IStreamReader* reader); bool parse(athena::io::IStreamReader* reader);
bool ClassTypeOperation(std::function<bool(const char* dnaType)> func); bool ClassTypeOperation(std::function<bool(const char* dnaType)> func);
bool ValidateClassType(const char* expectedType); bool ValidateClassType(const char* expectedType);
const YAMLNode* getRootNode() const { return m_rootNode.get(); } inline const YAMLNode* getRootNode() const { return m_rootNode.get(); }
const YAMLNode* getCurNode() const { return m_subStack.empty() ? nullptr : m_subStack.back(); } inline const YAMLNode* getCurNode() const { return m_subStack.empty() ? nullptr : m_subStack.back(); }
std::unique_ptr<YAMLNode> releaseRootNode() { return std::move(m_rootNode); } std::unique_ptr<YAMLNode> releaseRootNode() { return std::move(m_rootNode); }
class RecordRAII { class RecordRAII {
@ -54,7 +54,7 @@ public:
RecordRAII enterSubRecord(const char* name); RecordRAII enterSubRecord(const char* name);
template <class T> template <class T>
void enumerate(const char* name, T& record, std::enable_if_t<__IsDNARecord_v<T>>* = nullptr) { void enumerate(const char* name, T& record, typename std::enable_if_t<__IsDNARecord_v<T>>* = 0) {
if (auto rec = enterSubRecord(name)) if (auto rec = enterSubRecord(name))
record.read(*this); record.read(*this);
} }
@ -77,9 +77,10 @@ public:
VectorRAII enterSubVector(const char* name, size_t& countOut); VectorRAII enterSubVector(const char* name, size_t& countOut);
template <class T> template <class T>
size_t enumerate(const char* name, std::vector<T>& vector, size_t
std::enable_if_t<!std::is_arithmetic_v<T> && !std::is_same_v<T, atVec2f> && enumerate(const char* name, std::vector<T>& vector,
!std::is_same_v<T, atVec3f> && !std::is_same_v<T, atVec4f>>* = nullptr) { typename std::enable_if_t<!std::is_arithmetic<T>::value && !std::is_same<T, atVec2f>::value &&
!std::is_same<T, atVec3f>::value && !std::is_same<T, atVec4f>::value>* = 0) {
size_t countOut; size_t countOut;
if (auto v = enterSubVector(name, countOut)) { if (auto v = enterSubVector(name, countOut)) {
vector.clear(); vector.clear();
@ -95,8 +96,8 @@ public:
template <class T> template <class T>
size_t enumerate(const char* name, std::vector<T>& vector, size_t enumerate(const char* name, std::vector<T>& vector,
std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, atVec2f> || typename std::enable_if_t<std::is_arithmetic<T>::value || std::is_same<T, atVec2f>::value ||
std::is_same_v<T, atVec3f> || std::is_same_v<T, atVec4f>>* = nullptr) { std::is_same<T, atVec3f>::value || std::is_same<T, atVec4f>::value>* = 0) {
size_t countOut; size_t countOut;
if (auto v = enterSubVector(name, countOut)) { if (auto v = enterSubVector(name, countOut)) {
vector.clear(); vector.clear();

21
include/athena/YAMLDocWriter.hpp
View File

@ -20,7 +20,7 @@ public:
bool finish(athena::io::IStreamWriter* fout); bool finish(athena::io::IStreamWriter* fout);
YAMLNode* getCurNode() const { return m_subStack.empty() ? nullptr : m_subStack.back(); } inline YAMLNode* getCurNode() const { return m_subStack.empty() ? nullptr : m_subStack.back(); }
class RecordRAII { class RecordRAII {
friend class YAMLDocWriter; friend class YAMLDocWriter;
@ -40,7 +40,7 @@ public:
RecordRAII enterSubRecord(const char* name); RecordRAII enterSubRecord(const char* name);
template <class T> template <class T>
void enumerate(const char* name, T& record, std::enable_if_t<__IsDNARecord_v<T>>* = nullptr) { void enumerate(const char* name, T& record, typename std::enable_if_t<__IsDNARecord_v<T>>* = 0) {
if (auto rec = enterSubRecord(name)) if (auto rec = enterSubRecord(name))
record.write(*this); record.write(*this);
} }
@ -63,11 +63,11 @@ public:
VectorRAII enterSubVector(const char* name); VectorRAII enterSubVector(const char* name);
template <class T> template <class T>
void void enumerate(const char* name, const std::vector<T>& vector,
enumerate(const char* name, const std::vector<T>& vector, typename std::enable_if_t<!std::is_arithmetic<T>::value && !std::is_same<T, atVec2f>::value &&
std::enable_if_t<!std::is_arithmetic_v<T> && !std::is_same_v<T, atVec2f> && !std::is_same_v<T, atVec3f> && !std::is_same<T, atVec3f>::value && !std::is_same<T, atVec4f>::value &&
!std::is_same_v<T, atVec4f> && !std::is_same_v<T, atVec2d> && !std::is_same<T, atVec2d>::value && !std::is_same<T, atVec3d>::value &&
!std::is_same_v<T, atVec3d> && !std::is_same_v<T, atVec4d>>* = nullptr) { !std::is_same<T, atVec4d>::value>* = 0) {
if (auto v = enterSubVector(name)) if (auto v = enterSubVector(name))
for (const T& item : vector) for (const T& item : vector)
if (auto rec = enterSubRecord(nullptr)) if (auto rec = enterSubRecord(nullptr))
@ -76,9 +76,10 @@ public:
template <class T> template <class T>
void enumerate(const char* name, const std::vector<T>& vector, void enumerate(const char* name, const std::vector<T>& vector,
std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, atVec2f> || std::is_same_v<T, atVec3f> || typename std::enable_if_t<std::is_arithmetic<T>::value || std::is_same<T, atVec2f>::value ||
std::is_same_v<T, atVec4f> || std::is_same_v<T, atVec2d> || std::is_same<T, atVec3f>::value || std::is_same<T, atVec4f>::value ||
std::is_same_v<T, atVec3d> || std::is_same_v<T, atVec4d>>* = nullptr) { std::is_same<T, atVec2d>::value || std::is_same<T, atVec3d>::value ||
std::is_same<T, atVec4d>::value>* = 0) {
if (auto v = enterSubVector(name)) if (auto v = enterSubVector(name))
for (T item : vector) for (T item : vector)
writeVal<T>(nullptr, item); writeVal<T>(nullptr, item);

2
src/LZ77/LZType11.cpp
View File

@ -106,7 +106,7 @@ atUint32 LZType11::compress(const atUint8* src, atUint8** dst, atUint32 srcLengt
} }
delete[] compressedBytes; delete[] compressedBytes;
compressedBytes = nullptr; compressedBytes = NULL;
// Add zeros until the file is a multiple of 4 // Add zeros until the file is a multiple of 4
while ((outbuff.position() % 4) != 0) while ((outbuff.position() % 4) != 0)

4
src/athena/Compression.cpp
View File

@ -10,7 +10,7 @@
namespace athena::io::Compression { namespace athena::io::Compression {
atInt32 decompressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint32 dstLen) { atInt32 decompressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint32 dstLen) {
z_stream strm = {}; z_stream strm = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
strm.total_in = strm.avail_in = srcLen; strm.total_in = strm.avail_in = srcLen;
strm.total_out = strm.avail_out = dstLen; strm.total_out = strm.avail_out = dstLen;
strm.next_in = (Bytef*)src; strm.next_in = (Bytef*)src;
@ -45,7 +45,7 @@ atInt32 decompressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint
} }
atInt32 compressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint32 dstLen) { atInt32 compressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint32 dstLen) {
z_stream strm = {}; z_stream strm = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
strm.total_in = strm.avail_in = srcLen; strm.total_in = strm.avail_in = srcLen;
strm.total_out = strm.avail_out = dstLen; strm.total_out = strm.avail_out = dstLen;
strm.next_in = (Bytef*)src; strm.next_in = (Bytef*)src;

2
src/athena/Dir.cpp
View File

@ -45,7 +45,7 @@ bool Dir::cd(std::string_view path) {
bool Dir::rm(std::string_view path) { return !(remove((m_path + "/" + path.data()).c_str()) < 0); } bool Dir::rm(std::string_view path) { return !(remove((m_path + "/" + path.data()).c_str()) < 0); }
bool Dir::touch() { bool Dir::touch() {
std::srand(std::time(nullptr)); srand(time(NULL));
atUint64 tmp = utility::rand64(); atUint64 tmp = utility::rand64();
std::string tmpFile = fmt::format(fmt("{:016X}.tmp"), tmp); std::string tmpFile = fmt::format(fmt("{:016X}.tmp"), tmp);
bool ret = FileInfo(m_path + "/" + tmpFile).touch(); bool ret = FileInfo(m_path + "/" + tmpFile).touch();

16
src/athena/FileInfo.cpp
View File

@ -104,7 +104,7 @@ bool FileInfo::touch() const {
(void)athena::io::FileWriter(m_path); (void)athena::io::FileWriter(m_path);
return true; return true;
} }
if (utimes(m_path.c_str(), nullptr) < 0) { if (utimes(m_path.c_str(), NULL) < 0) {
return false; return false;
} }
#elif defined(_WIN32) #elif defined(_WIN32)
@ -114,7 +114,7 @@ bool FileInfo::touch() const {
wchar_t date[80], time[80]; wchar_t date[80], time[80];
#if !WINDOWS_STORE #if !WINDOWS_STORE
fh = CreateFileA(m_path.c_str(), GENERIC_READ | FILE_WRITE_ATTRIBUTES, 0, nullptr, CREATE_NEW, 0, nullptr); fh = CreateFileA(m_path.c_str(), GENERIC_READ | FILE_WRITE_ATTRIBUTES, 0, NULL, CREATE_NEW, 0, NULL);
if (fh == INVALID_HANDLE_VALUE) if (fh == INVALID_HANDLE_VALUE)
return false; return false;
@ -122,14 +122,14 @@ bool FileInfo::touch() const {
/* /*
* Use GetFileTime() to get the file modification time. * Use GetFileTime() to get the file modification time.
*/ */
if (GetFileTime(fh, nullptr, nullptr, &modtime) == 0) { if (GetFileTime(fh, NULL, NULL, &modtime) == 0) {
CloseHandle(fh); CloseHandle(fh);
return false; return false;
} }
FileTimeToSystemTime(&modtime, &st); FileTimeToSystemTime(&modtime, &st);
if (GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, nullptr, date, sizeof date / sizeof date[0]) == 0 || if (GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, date, sizeof date / sizeof date[0]) == 0 ||
GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, nullptr, time, sizeof time / sizeof time[0]) == 0) { GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, time, sizeof time / sizeof time[0]) == 0) {
CloseHandle(fh); CloseHandle(fh);
return false; return false;
} }
@ -139,13 +139,13 @@ bool FileInfo::touch() const {
* to the current time. * to the current time.
*/ */
GetSystemTime(&st); GetSystemTime(&st);
if (GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, nullptr, date, sizeof date / sizeof date[0]) == 0 || if (GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, date, sizeof date / sizeof date[0]) == 0 ||
GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, nullptr, time, sizeof time / sizeof time[0]) == 0) { GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, time, sizeof time / sizeof time[0]) == 0) {
CloseHandle(fh); CloseHandle(fh);
return false; return false;
} }
SystemTimeToFileTime(&st, &modtime); SystemTimeToFileTime(&st, &modtime);
if (SetFileTime(fh, nullptr, nullptr, &modtime) == 0) { if (SetFileTime(fh, NULL, NULL, &modtime) == 0) {
CloseHandle(fh); CloseHandle(fh);
return false; return false;
} }

4
src/athena/Socket.cpp
View File

@ -45,8 +45,8 @@ void IPAddress::resolve(const std::string& address) {
addrinfo hints; addrinfo hints;
memset(&hints, 0, sizeof(hints)); memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET; hints.ai_family = AF_INET;
addrinfo* result = nullptr; addrinfo* result = NULL;
if (getaddrinfo(address.c_str(), nullptr, &hints, &result) == 0) { if (getaddrinfo(address.c_str(), NULL, &hints, &result) == 0) {
if (result) { if (result) {
addr = reinterpret_cast<sockaddr_in*>(result->ai_addr)->sin_addr; addr = reinterpret_cast<sockaddr_in*>(result->ai_addr)->sin_addr;
freeaddrinfo(result); freeaddrinfo(result);

2
src/athena/Utility.cpp
View File

@ -100,7 +100,7 @@ int countChar(std::string_view str, const char chr, int* lastOccur) {
for (char c : str) { for (char c : str) {
if (c == chr) { if (c == chr) {
if (lastOccur != nullptr) if (lastOccur != NULL)
*lastOccur = index; *lastOccur = index;
ret++; ret++;