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

Huge non-virtual template-based refactor for DNA

This commit is contained in:
Jack Andersen 2018-02-17 23:50:24 -10:00
parent 42b97e0306
commit 13d13f935b
30 changed files with 2632 additions and 2407 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
atdna/CMakeLists.txt
View File

@ -234,4 +234,9 @@ macro(atdna out)
endif() endif()
endmacro() endmacro()
# Test target
atdna(atdna_test.cpp test.hpp)
add_executable(atdna-test test.cpp atdna_test.cpp test.hpp)
target_link_libraries(atdna-test athena-core athena-libyaml)
endif() endif()

2173
atdna/main.cpp
View File

File diff suppressed because it is too large Load Diff

24
atdna/test.cpp Normal file
View File

@ -0,0 +1,24 @@
#include "test.hpp"
#include "athena/MemoryWriter.hpp"
#define EXPECTED_BYTES 265
int main(int argc, const char** argv)
{
TESTFile file = {};
file.arrCount[0] = 2;
file.array.push_back(42);
file.array.push_back(64);
size_t binSize = 0;
file.binarySize(binSize);
athena::io::MemoryCopyWriter w(nullptr, binSize);
atInt64 pos = w.position();
file.write(w);
bool pass = !w.hasError() && w.position() - pos == binSize && binSize == EXPECTED_BYTES;
if (pass)
printf("[PASS] %" PRISize " bytes written\n", size_t(w.position() - pos));
else
printf("[FAIL] %" PRISize " bytes written; %" PRISize " bytes sized; %d bytes expected\n",
size_t(w.position() - pos), binSize, EXPECTED_BYTES);
return pass ? 0 : 1;
}

21
atdna/test.hpp
View File

@ -1,11 +1,11 @@
#include <athena/DNAYaml.hpp> #include <athena/DNAYaml.hpp>
using namespace athena; using namespace athena;
typedef io::DNAYaml<BigEndian> BigDNA; typedef io::DNA<Big> BigDNA;
struct TESTSubFile : public BigDNA struct TESTSubFile : public BigDNA
{ {
DECL_YAML AT_DECL_DNA
enum ETest : atUint8 enum ETest : atUint8
{ {
ZERO, ZERO,
@ -20,30 +20,30 @@ struct TESTSubFile : public BigDNA
struct TESTSubClassFile : public TESTSubFile struct TESTSubClassFile : public TESTSubFile
{ {
DECL_YAML AT_DECL_DNA
Value<atUint32> sub3; Value<atUint32> sub3;
Value<atUint32> sub4; Value<atUint32> sub4;
}; };
struct TESTSubSubClassFile : public TESTSubClassFile struct TESTSubSubClassFile : public TESTSubClassFile
{ {
DECL_YAML AT_DECL_DNA
Value<atUint32> sub5; Value<atUint32> sub5;
Value<atUint32> sub6; Value<atUint32> sub6;
}; };
struct TESTFile : public BigDNA struct TESTFile : public BigDNA
{ {
DECL_YAML AT_DECL_DNA
Value<bool> varBool; Value<bool> varBool;
Value<atUint32> var32; AT_OVERRIDE_RCRC32(12345678) Value<atUint32> x4_var32;
Value<atUint16> var16; AT_OVERRIDE_RCRC32(deadbabe) Value<atUint16> x8_var16;
Value<atVec3f> vec3; Value<atVec3f> vec3;
Value<atVec4f> vec4; Value<atVec4f> vec4;
struct TESTNestedSubFile : public BigDNA struct TESTNestedSubFile : public BigDNA
{ {
DECL_YAML AT_DECL_DNA
Value<atUint32> nestSub1; Value<atUint32> nestSub1;
Value<atUint32> nestSub2; Value<atUint32> nestSub2;
} nestedSubFile; } nestedSubFile;
@ -55,12 +55,12 @@ struct TESTFile : public BigDNA
struct TESTExplicitSubFile : public BigDNA struct TESTExplicitSubFile : public BigDNA
{ {
DECL_YAML AT_DECL_DNA
Value<atUint32> explSub1; Value<atUint32> explSub1;
Value<atUint32> explSub2; Value<atUint32> explSub2;
} explSubFile; } explSubFile;
Value<atUint32, LittleEndian> arrCount[2]; Value<atUint32, Little> arrCount[2];
Vector<atUint32, DNA_COUNT(arrCount[0])> array; Vector<atUint32, DNA_COUNT(arrCount[0])> array;
Seek<21, Current> seek; Seek<21, Current> seek;
@ -73,6 +73,5 @@ struct TESTFile : public BigDNA
String<32> str; String<32> str;
WString<64> wstr; WString<64> wstr;
WStringAsString<> utf8str[5];
}; };

2
include/athena/Checksums.hpp
View File

@ -3,7 +3,7 @@
#include "athena/Global.hpp" #include "athena/Global.hpp"
namespace athena::Checksums namespace athena::checksums
{ {
atUint32 crc32(const atUint8* data, atUint64 length, atUint32 mask = 0xFFFFFFFF, atUint32 seed = 0xFFFFFFFF); atUint32 crc32(const atUint8* data, atUint64 length, atUint32 mask = 0xFFFFFFFF, atUint32 seed = 0xFFFFFFFF);
atUint16 crc16CCITT(const atUint8* data, atUint64 length, atUint16 seed = 0xFFFF, atUint16 final = 0); atUint16 crc16CCITT(const atUint8* data, atUint64 length, atUint16 seed = 0xFFFF, atUint16 final = 0);

199
include/athena/ChecksumsLiterals.hpp Normal file
View File

@ -0,0 +1,199 @@
#ifndef AT_CHECKSUMSLITERALS_HPP
#define AT_CHECKSUMSLITERALS_HPP
#include <cstdint>
namespace athena::checksums::literals
{
constexpr uint32_t crc32_table[] =
{
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
};
template<uint32_t CRC, char ...Chars> struct Crc32Impl {
};
template<uint32_t CRC, char Head, char ...Tail> struct Crc32Impl<CRC, Head, Tail...> {
static constexpr uint32_t value = Crc32Impl<
crc32_table[static_cast<unsigned char>(CRC) ^ static_cast<unsigned char>(Head)]
^ (CRC >> 8), Tail...>::value;
};
template<uint32_t CRC> struct Crc32Impl<CRC> {
static constexpr uint32_t value = CRC ^ 0xFFFFFFFF;
};
template<char ...Chars> using Crc32 = Crc32Impl<0xFFFFFFFF, Chars...>;
constexpr uint32_t crc32_rec(uint32_t crc, const char *s) {
return *s == 0 ? crc ^ 0xFFFFFFFF :
crc32_rec(crc32_table[static_cast<unsigned char>(crc) ^
static_cast<unsigned char>(*s)]
^ (crc >> 8), s + 1);
}
constexpr uint32_t operator "" _crc32(const char *s, size_t len) {
return crc32_rec(0xFFFFFFFF, s);
}
static_assert("Hello"_crc32 == Crc32<'H', 'e', 'l', 'l', 'o'>::value,
"CRC32 values don't match");
static_assert("0"_crc32 == Crc32<'0'>::value,
"CRC32 values don't match");
constexpr uint32_t rcrc32_rec(uint32_t crc, const char *s) {
return *s == 0 ? crc :
crc32_rec(crc32_table[static_cast<unsigned char>(crc) ^
static_cast<unsigned char>(*s)]
^ (crc >> 8), s + 1);
}
constexpr uint32_t operator "" _rcrc32(const char *s, size_t len) {
return rcrc32_rec(0xFFFFFFFF, s);
}
static_assert("Hello"_rcrc32 == Crc32<'H', 'e', 'l', 'l', 'o'>::value,
"CRC32 values don't match");
static_assert("0"_rcrc32 == Crc32<'0'>::value,
"CRC32 values don't match");
constexpr uint64_t crc64_table[] =
{
0x0000000000000000, 0x42F0E1EBA9EA3693, 0x85E1C3D753D46D26, 0xC711223CFA3E5BB5,
0x493366450E42ECDF, 0x0BC387AEA7A8DA4C, 0xCCD2A5925D9681F9, 0x8E224479F47CB76A,
0x9266CC8A1C85D9BE, 0xD0962D61B56FEF2D, 0x17870F5D4F51B498, 0x5577EEB6E6BB820B,
0xDB55AACF12C73561, 0x99A54B24BB2D03F2, 0x5EB4691841135847, 0x1C4488F3E8F96ED4,
0x663D78FF90E185EF, 0x24CD9914390BB37C, 0xE3DCBB28C335E8C9, 0xA12C5AC36ADFDE5A,
0x2F0E1EBA9EA36930, 0x6DFEFF5137495FA3, 0xAAEFDD6DCD770416, 0xE81F3C86649D3285,
0xF45BB4758C645C51, 0xB6AB559E258E6AC2, 0x71BA77A2DFB03177, 0x334A9649765A07E4,
0xBD68D2308226B08E, 0xFF9833DB2BCC861D, 0x388911E7D1F2DDA8, 0x7A79F00C7818EB3B,
0xCC7AF1FF21C30BDE, 0x8E8A101488293D4D, 0x499B3228721766F8, 0x0B6BD3C3DBFD506B,
0x854997BA2F81E701, 0xC7B97651866BD192, 0x00A8546D7C558A27, 0x4258B586D5BFBCB4,
0x5E1C3D753D46D260, 0x1CECDC9E94ACE4F3, 0xDBFDFEA26E92BF46, 0x990D1F49C77889D5,
0x172F5B3033043EBF, 0x55DFBADB9AEE082C, 0x92CE98E760D05399, 0xD03E790CC93A650A,
0xAA478900B1228E31, 0xE8B768EB18C8B8A2, 0x2FA64AD7E2F6E317, 0x6D56AB3C4B1CD584,
0xE374EF45BF6062EE, 0xA1840EAE168A547D, 0x66952C92ECB40FC8, 0x2465CD79455E395B,
0x3821458AADA7578F, 0x7AD1A461044D611C, 0xBDC0865DFE733AA9, 0xFF3067B657990C3A,
0x711223CFA3E5BB50, 0x33E2C2240A0F8DC3, 0xF4F3E018F031D676, 0xB60301F359DBE0E5,
0xDA050215EA6C212F, 0x98F5E3FE438617BC, 0x5FE4C1C2B9B84C09, 0x1D14202910527A9A,
0x93366450E42ECDF0, 0xD1C685BB4DC4FB63, 0x16D7A787B7FAA0D6, 0x5427466C1E109645,
0x4863CE9FF6E9F891, 0x0A932F745F03CE02, 0xCD820D48A53D95B7, 0x8F72ECA30CD7A324,
0x0150A8DAF8AB144E, 0x43A04931514122DD, 0x84B16B0DAB7F7968, 0xC6418AE602954FFB,
0xBC387AEA7A8DA4C0, 0xFEC89B01D3679253, 0x39D9B93D2959C9E6, 0x7B2958D680B3FF75,
0xF50B1CAF74CF481F, 0xB7FBFD44DD257E8C, 0x70EADF78271B2539, 0x321A3E938EF113AA,
0x2E5EB66066087D7E, 0x6CAE578BCFE24BED, 0xABBF75B735DC1058, 0xE94F945C9C3626CB,
0x676DD025684A91A1, 0x259D31CEC1A0A732, 0xE28C13F23B9EFC87, 0xA07CF2199274CA14,
0x167FF3EACBAF2AF1, 0x548F120162451C62, 0x939E303D987B47D7, 0xD16ED1D631917144,
0x5F4C95AFC5EDC62E, 0x1DBC74446C07F0BD, 0xDAAD56789639AB08, 0x985DB7933FD39D9B,
0x84193F60D72AF34F, 0xC6E9DE8B7EC0C5DC, 0x01F8FCB784FE9E69, 0x43081D5C2D14A8FA,
0xCD2A5925D9681F90, 0x8FDAB8CE70822903, 0x48CB9AF28ABC72B6, 0x0A3B7B1923564425,
0x70428B155B4EAF1E, 0x32B26AFEF2A4998D, 0xF5A348C2089AC238, 0xB753A929A170F4AB,
0x3971ED50550C43C1, 0x7B810CBBFCE67552, 0xBC902E8706D82EE7, 0xFE60CF6CAF321874,
0xE224479F47CB76A0, 0xA0D4A674EE214033, 0x67C58448141F1B86, 0x253565A3BDF52D15,
0xAB1721DA49899A7F, 0xE9E7C031E063ACEC, 0x2EF6E20D1A5DF759, 0x6C0603E6B3B7C1CA,
0xF6FAE5C07D3274CD, 0xB40A042BD4D8425E, 0x731B26172EE619EB, 0x31EBC7FC870C2F78,
0xBFC9838573709812, 0xFD39626EDA9AAE81, 0x3A28405220A4F534, 0x78D8A1B9894EC3A7,
0x649C294A61B7AD73, 0x266CC8A1C85D9BE0, 0xE17DEA9D3263C055, 0xA38D0B769B89F6C6,
0x2DAF4F0F6FF541AC, 0x6F5FAEE4C61F773F, 0xA84E8CD83C212C8A, 0xEABE6D3395CB1A19,
0x90C79D3FEDD3F122, 0xD2377CD44439C7B1, 0x15265EE8BE079C04, 0x57D6BF0317EDAA97,
0xD9F4FB7AE3911DFD, 0x9B041A914A7B2B6E, 0x5C1538ADB04570DB, 0x1EE5D94619AF4648,
0x02A151B5F156289C, 0x4051B05E58BC1E0F, 0x87409262A28245BA, 0xC5B073890B687329,
0x4B9237F0FF14C443, 0x0962D61B56FEF2D0, 0xCE73F427ACC0A965, 0x8C8315CC052A9FF6,
0x3A80143F5CF17F13, 0x7870F5D4F51B4980, 0xBF61D7E80F251235, 0xFD913603A6CF24A6,
0x73B3727A52B393CC, 0x31439391FB59A55F, 0xF652B1AD0167FEEA, 0xB4A25046A88DC879,
0xA8E6D8B54074A6AD, 0xEA16395EE99E903E, 0x2D071B6213A0CB8B, 0x6FF7FA89BA4AFD18,
0xE1D5BEF04E364A72, 0xA3255F1BE7DC7CE1, 0x64347D271DE22754, 0x26C49CCCB40811C7,
0x5CBD6CC0CC10FAFC, 0x1E4D8D2B65FACC6F, 0xD95CAF179FC497DA, 0x9BAC4EFC362EA149,
0x158E0A85C2521623, 0x577EEB6E6BB820B0, 0x906FC95291867B05, 0xD29F28B9386C4D96,
0xCEDBA04AD0952342, 0x8C2B41A1797F15D1, 0x4B3A639D83414E64, 0x09CA82762AAB78F7,
0x87E8C60FDED7CF9D, 0xC51827E4773DF90E, 0x020905D88D03A2BB, 0x40F9E43324E99428,
0x2CFFE7D5975E55E2, 0x6E0F063E3EB46371, 0xA91E2402C48A38C4, 0xEBEEC5E96D600E57,
0x65CC8190991CB93D, 0x273C607B30F68FAE, 0xE02D4247CAC8D41B, 0xA2DDA3AC6322E288,
0xBE992B5F8BDB8C5C, 0xFC69CAB42231BACF, 0x3B78E888D80FE17A, 0x7988096371E5D7E9,
0xF7AA4D1A85996083, 0xB55AACF12C735610, 0x724B8ECDD64D0DA5, 0x30BB6F267FA73B36,
0x4AC29F2A07BFD00D, 0x08327EC1AE55E69E, 0xCF235CFD546BBD2B, 0x8DD3BD16FD818BB8,
0x03F1F96F09FD3CD2, 0x41011884A0170A41, 0x86103AB85A2951F4, 0xC4E0DB53F3C36767,
0xD8A453A01B3A09B3, 0x9A54B24BB2D03F20, 0x5D45907748EE6495, 0x1FB5719CE1045206,
0x919735E51578E56C, 0xD367D40EBC92D3FF, 0x1476F63246AC884A, 0x568617D9EF46BED9,
0xE085162AB69D5E3C, 0xA275F7C11F7768AF, 0x6564D5FDE549331A, 0x279434164CA30589,
0xA9B6706FB8DFB2E3, 0xEB46918411358470, 0x2C57B3B8EB0BDFC5, 0x6EA7525342E1E956,
0x72E3DAA0AA188782, 0x30133B4B03F2B111, 0xF7021977F9CCEAA4, 0xB5F2F89C5026DC37,
0x3BD0BCE5A45A6B5D, 0x79205D0E0DB05DCE, 0xBE317F32F78E067B, 0xFCC19ED95E6430E8,
0x86B86ED5267CDBD3, 0xC4488F3E8F96ED40, 0x0359AD0275A8B6F5, 0x41A94CE9DC428066,
0xCF8B0890283E370C, 0x8D7BE97B81D4019F, 0x4A6ACB477BEA5A2A, 0x089A2AACD2006CB9,
0x14DEA25F3AF9026D, 0x562E43B4931334FE, 0x913F6188692D6F4B, 0xD3CF8063C0C759D8,
0x5DEDC41A34BBEEB2, 0x1F1D25F19D51D821, 0xD80C07CD676F8394, 0x9AFCE626CE85B507
};
template<uint64_t CRC, char ...Chars> struct Crc64Impl {
};
template<uint64_t CRC, char Head, char ...Tail> struct Crc64Impl<CRC, Head, Tail...> {
static constexpr uint64_t value = Crc64Impl<
crc64_table[static_cast<unsigned char>(CRC >> 56) ^ static_cast<unsigned char>(Head)]
^ (CRC << 8), Tail...>::value;
};
template<uint64_t CRC> struct Crc64Impl<CRC> {
static constexpr uint64_t value = CRC ^ 0xFFFFFFFFFFFFFFFF;
};
template<char ...Chars> using Crc64 = Crc64Impl<0xFFFFFFFFFFFFFFFF, Chars...>;
constexpr uint64_t crc64_rec(uint64_t crc, const char *s) {
return *s == 0 ? crc ^ 0xFFFFFFFFFFFFFFFF :
crc64_rec(crc64_table[static_cast<unsigned char>(crc >> 56) ^
static_cast<unsigned char>(*s)]
^ (crc << 8), s + 1);
}
constexpr uint64_t operator "" _crc64(const char *s, size_t len) {
return crc64_rec(0xFFFFFFFFFFFFFFFF, s);
}
static_assert("Hello"_crc64 == Crc64<'H', 'e', 'l', 'l', 'o'>::value,
"CRC64 values don't match");
static_assert("0"_crc64 == Crc64<'0'>::value,
"CRC64 values don't match");
}
#endif // AT_CHECKSUMSLITERALS_HPP

157
include/athena/DNA.hpp
View File

@ -10,26 +10,13 @@
#include "Global.hpp" #include "Global.hpp"
#include "IStreamReader.hpp" #include "IStreamReader.hpp"
#include "IStreamWriter.hpp" #include "IStreamWriter.hpp"
#include "DNAOp.hpp"
#include <vector> #include <vector>
#include <memory> #include <memory>
namespace athena::io namespace athena::io
{ {
/* forward-declaration dance for recursively-derived types */
template <size_t sizeVar, Endian VE>
struct Buffer;
template <atInt32 sizeVar, Endian VE>
struct String;
template <atInt32 sizeVar, Endian VE>
struct WString;
template <atInt32 sizeVar, Endian VE>
struct WStringAsString;
/** /**
* @brief Base DNA class used against 'atdna' * @brief Base DNA class used against 'atdna'
* @tparam DNAE Default-endianness for contained DNA values * @tparam DNAE Default-endianness for contained DNA values
@ -42,22 +29,10 @@ struct WStringAsString;
template <Endian DNAE> template <Endian DNAE>
struct DNA struct DNA
{ {
virtual ~DNA() = default;
/** /**
* @brief Common virtual read function for all DNA types * @brief Designated byte-order used for serializing fields
*/ */
virtual void read(IStreamReader&)=0; static constexpr Endian DNAEndian = DNAE;
/**
* @brief Common virtual write function for all DNA types
*/
virtual void write(IStreamWriter&) const=0;
/**
* @brief Common virtual binary size computation for all DNA types
* @param __isz initial cumulative value to add result to
* @return Cumulative size
*/
virtual size_t binarySize(size_t __isz) const=0;
/** /**
* @brief Template type signaling atdna to capture the value where it's used * @brief Template type signaling atdna to capture the value where it's used
@ -82,7 +57,7 @@ struct DNA
* @tparam sizeVar C++ expression wrapped in DNA_COUNT macro to determine number of bytes for buffer * @tparam sizeVar C++ expression wrapped in DNA_COUNT macro to determine number of bytes for buffer
*/ */
template <size_t sizeVar> template <size_t sizeVar>
using Buffer = struct athena::io::Buffer<sizeVar, DNAE>; using Buffer = std::unique_ptr<atUint8[]>;
/** /**
* @brief Template type wrapping std::string and signaling atdna to read string data where it's used * @brief Template type wrapping std::string and signaling atdna to read string data where it's used
@ -90,7 +65,7 @@ struct DNA
* -1 literal indicates null-terminated string * -1 literal indicates null-terminated string
*/ */
template <atInt32 sizeVar = -1> template <atInt32 sizeVar = -1>
using String = struct athena::io::String<sizeVar, DNAE>; using String = std::string;
/** /**
* @brief Template type wrapping std::wstring and signaling atdna to read wstring data where it's used * @brief Template type wrapping std::wstring and signaling atdna to read wstring data where it's used
@ -98,15 +73,7 @@ struct DNA
* -1 literal indicates null-terminated wstring * -1 literal indicates null-terminated wstring
*/ */
template <atInt32 sizeVar = -1, Endian VE = DNAE> template <atInt32 sizeVar = -1, Endian VE = DNAE>
using WString = struct athena::io::WString<sizeVar, VE>; using WString = std::wstring;
/**
* @brief Template type wrapping std::string and signaling atdna to read wstring data where it's used
* @tparam sizeVar C++ expression wrapped in DNA_COUNT macro to determine number of characters for string
* -1 literal indicates null-terminated string
*/
template <atInt32 sizeVar = -1>
using WStringAsString = struct athena::io::WStringAsString<sizeVar, DNAE>;
/** /**
* @brief Meta Template signaling atdna to insert a stream seek where it's used * @brief Meta Template signaling atdna to insert a stream seek where it's used
@ -127,120 +94,8 @@ struct DNA
* @brief Meta Template preventing atdna from emitting read/write implementations * @brief Meta Template preventing atdna from emitting read/write implementations
*/ */
struct Delete {}; struct Delete {};
/**
* @brief Internal DNA helper for accumulating binarySize
* @param __isz initial size value
* @param v Vector to enumerate
* @return Cumulative total
*/
template <typename T>
static size_t __EnumerateSize(size_t __isz, const T& v)
{
for (const auto& val : v)
__isz = val.binarySize(__isz);
return __isz;
}
}; };
/**
* @brief Concrete buffer type used by DNA::Buffer
*/
template <size_t sizeVar, Endian VE>
struct Buffer : public DNA<VE>, public std::unique_ptr<atUint8[]>
{
typename DNA<VE>::Delete expl;
void read(IStreamReader& reader)
{
reset(new atUint8[sizeVar]);
reader.readUBytesToBuf(get(), sizeVar);
}
void write(IStreamWriter& writer) const
{
writer.writeUBytes(get(), sizeVar);
}
size_t binarySize(size_t __isz) const
{
return __isz + sizeVar;
}
};
/**
* @brief Concrete string type used by DNA::String
*/
template <atInt32 sizeVar, Endian VE>
struct String : public DNA<VE>, public std::string
{
typename DNA<VE>::Delete expl;
void read(IStreamReader& reader)
{this->assign(std::move(reader.readString(sizeVar)));}
void write(IStreamWriter& writer) const
{writer.writeString(*this, sizeVar);}
size_t binarySize(size_t __isz) const
{return __isz + ((sizeVar<0)?(this->size()+1):sizeVar);}
std::string& operator=(std::string_view __str)
{return this->assign(__str);}
std::string& operator=(std::string&& __str)
{this->swap(__str); return *this;}
};
/**
* @brief Concrete wstring type used by DNA::WString
*/
template <atInt32 sizeVar, Endian VE>
struct WString : public DNA<VE>, public std::wstring
{
typename DNA<VE>::Delete expl;
void read(IStreamReader& reader)
{
reader.setEndian(VE);
this->assign(std::move(reader.readWString(sizeVar)));
}
void write(IStreamWriter& writer) const
{
writer.setEndian(VE);
writer.writeWString(*this, sizeVar);
}
size_t binarySize(size_t __isz) const
{return __isz + (((sizeVar<0)?(this->size()+1):sizeVar)*2);}
std::wstring& operator=(std::wstring_view __str)
{return this->assign(__str);}
std::wstring& operator=(std::wstring&& __str)
{this->swap(__str); return *this;}
};
/**
* @brief Concrete converting-wstring type used by DNA::WStringAsString
*/
template <atInt32 sizeVar, Endian VE>
struct WStringAsString : public DNA<VE>, public std::string
{
typename DNA<VE>::Delete expl;
void read(IStreamReader& reader)
{*this = reader.readWStringAsString(sizeVar);}
void write(IStreamWriter& writer) const
{writer.writeStringAsWString(*this, sizeVar);}
size_t binarySize(size_t __isz) const
{return __isz + (((sizeVar<0)?(this->size()+1):sizeVar)*2);}
std::string& operator=(std::string_view __str)
{return this->assign(__str);}
std::string& operator=(std::string&& __str)
{this->swap(__str); return *this;}
};
/** Macro to automatically declare read/write methods in subclasses */
#define DECL_DNA \
void read(athena::io::IStreamReader&); \
void write(athena::io::IStreamWriter&) const; \
size_t binarySize(size_t __isz) const;
/** Macro to automatically declare read/write methods and prevent outputting implementation */
#define DECL_EXPLICIT_DNA \
void read(athena::io::IStreamReader&); \
void write(athena::io::IStreamWriter&) const; \
size_t binarySize(size_t __isz) const; \
Delete __dna_delete;
/** Macro to supply count variable to atdna and mute it for other compilers */ /** Macro to supply count variable to atdna and mute it for other compilers */
#ifdef __clang__ #ifdef __clang__
#define DNA_COUNT(cnt) sizeof(cnt) #define DNA_COUNT(cnt) sizeof(cnt)

908
include/athena/DNAOp.hpp Normal file
View File

@ -0,0 +1,908 @@
#ifndef AT_OP_HPP
#define AT_OP_HPP
#include "IStreamReader.hpp"
#include "IStreamWriter.hpp"
#include "DNAYaml.hpp"
#include "ChecksumsLiterals.hpp"
namespace athena::io
{
struct PropId
{
const char* name = nullptr;
uint32_t rcrc32 = 0xffffffff;
uint64_t crc64 = 0x0;
template <class T> constexpr T opget() const;
constexpr PropId() = default;
constexpr PropId(const char* name, uint32_t rcrc32, uint64_t crc64)
: name(name), rcrc32(rcrc32), crc64(crc64) {}
constexpr PropId(const char* name)
: name(name),
rcrc32(athena::checksums::literals::rcrc32_rec(0xFFFFFFFF, name)),
crc64(athena::checksums::literals::crc64_rec(0xFFFFFFFFFFFFFFFF, name)) {}
constexpr PropId(const char* name, uint32_t rcrc32)
: name(name),
rcrc32(rcrc32),
crc64(athena::checksums::literals::crc64_rec(0xFFFFFFFFFFFFFFFF, name)) {}
};
template <>
constexpr uint32_t PropId::opget<uint32_t>() const { return rcrc32; }
template <>
constexpr uint64_t PropId::opget<uint64_t>() const { return crc64; }
namespace literals
{
constexpr PropId operator "" _propid(const char* s, size_t len)
{
return {s};
}
}
#define AT_PROP_CASE(...) case athena::io::PropId(__VA_ARGS__).opget<typename Op::PropT>()
#if defined(__atdna__)
# define AT_OVERRIDE_RCRC32(rcrc32) __attribute__((annotate("rcrc32=" #rcrc32)))
#else
# define AT_OVERRIDE_RCRC32(rcrc32)
#endif
enum class PropType
{
None,
CRC32,
CRC64
};
template <class T>
static inline constexpr bool __IsPODType()
{
return std::is_arithmetic<T>::value ||
std::is_same<T, atVec2f>::value ||
std::is_same<T, atVec3f>::value ||
std::is_same<T, atVec4f>::value ||
std::is_same<T, atVec2d>::value ||
std::is_same<T, atVec3d>::value ||
std::is_same<T, atVec4d>::value;
}
template <PropType PropOp>
struct BinarySize
{
using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>;
using StreamT = size_t;
template <class T, Endian DNAE>
static typename std::enable_if_t<std::is_enum_v<T>>
Do(const PropId& id, T& var, StreamT& s)
{
if (PropOp != PropType::None)
{
/* Accessed via Enumerate, header */
s += 6;
}
using PODType = std::underlying_type_t<T>;
BinarySize<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), s);
}
template <class T, Endian DNAE>
static typename std::enable_if_t<__IsPODType<T>()>
Do(const PropId& id, T& var, StreamT& s)
{
if (PropOp != PropType::None)
{
/* Accessed via Enumerate, header */
s += 6;
}
BinarySize<PropType::None>::Do<T, DNAE>(id, var, s);
}
template <class T, Endian DNAE>
static typename std::enable_if_t<!std::is_enum_v<T> && !__IsPODType<T>()>
Do(const PropId& id, T& var, StreamT& s)
{
if (PropOp != PropType::None)
{
/* Accessed via Enumerate, header */
s += 6;
var.template Enumerate<BinarySize<PropOp>>(s);
}
else
var.template Enumerate<BinarySize>(s);
}
template <class T, Endian DNAE>
static void Do(const PropId& id, std::vector<T>& vector, size_t count, StreamT& s)
{
for (T& v : vector)
BinarySize<PropOp>::Do<T, DNAE>(id, v, s);
}
static void Do(const PropId& id, std::unique_ptr<atUint8[]>& buf, size_t count, StreamT& s)
{
if (buf)
s += count;
}
static void Do(const PropId& id, std::string& str, StreamT& s)
{
s += str.size() + 1;
}
static void Do(const PropId& id, std::string& str, size_t count, StreamT& s)
{
s += count;
}
template <Endian DNAE>
static void Do(const PropId& id, std::wstring& str, StreamT& s)
{
s += str.size() * 2 + 2;
}
template <Endian DNAE>
static void Do(const PropId& id, std::wstring& str, size_t count, StreamT& s)
{
s += count * 2;
}
static void DoSeek(atInt64 amount, SeekOrigin whence, StreamT& s)
{
switch (whence)
{
case SeekOrigin::Begin:
s = amount;
break;
case SeekOrigin::Current:
s += amount;
break;
default:
break;
}
}
static void DoAlign(atInt64 amount, StreamT& s)
{
s = (s + amount-1) / amount * amount;
}
};
template <> template <> inline void BinarySize<PropType::None>::Do<bool, Endian::Big>(const PropId& id, bool& var, BinarySize::StreamT& s) { s += 1; }
template <> template <> inline void BinarySize<PropType::None>::Do<atInt8, Endian::Big>(const PropId& id, atInt8& var, BinarySize::StreamT& s) { s += 1; }
template <> template <> inline void BinarySize<PropType::None>::Do<atUint8, Endian::Big>(const PropId& id, atUint8& var, BinarySize::StreamT& s) { s += 1; }
template <> template <> inline void BinarySize<PropType::None>::Do<atInt16, Endian::Big>(const PropId& id, atInt16& var, BinarySize::StreamT& s) { s += 2; }
template <> template <> inline void BinarySize<PropType::None>::Do<atUint16, Endian::Big>(const PropId& id, atUint16& var, BinarySize::StreamT& s) { s += 2; }
template <> template <> inline void BinarySize<PropType::None>::Do<atInt32, Endian::Big>(const PropId& id, atInt32& var, BinarySize::StreamT& s) { s += 4; }
template <> template <> inline void BinarySize<PropType::None>::Do<atUint32, Endian::Big>(const PropId& id, atUint32& var, BinarySize::StreamT& s) { s += 4; }
template <> template <> inline void BinarySize<PropType::None>::Do<atInt64, Endian::Big>(const PropId& id, atInt64& var, BinarySize::StreamT& s) { s += 8; }
template <> template <> inline void BinarySize<PropType::None>::Do<atUint64, Endian::Big>(const PropId& id, atUint64& var, BinarySize::StreamT& s) { s += 8; }
template <> template <> inline void BinarySize<PropType::None>::Do<float, Endian::Big>(const PropId& id, float& var, BinarySize::StreamT& s) { s += 4; }
template <> template <> inline void BinarySize<PropType::None>::Do<double, Endian::Big>(const PropId& id, double& var, BinarySize::StreamT& s) { s += 8; }
template <> template <> inline void BinarySize<PropType::None>::Do<atVec2f, Endian::Big>(const PropId& id, atVec2f& var, BinarySize::StreamT& s) { s += 8; }
template <> template <> inline void BinarySize<PropType::None>::Do<atVec2d, Endian::Big>(const PropId& id, atVec2d& var, BinarySize::StreamT& s) { s += 16; }
template <> template <> inline void BinarySize<PropType::None>::Do<atVec3f, Endian::Big>(const PropId& id, atVec3f& var, BinarySize::StreamT& s) { s += 12; }
template <> template <> inline void BinarySize<PropType::None>::Do<atVec3d, Endian::Big>(const PropId& id, atVec3d& var, BinarySize::StreamT& s) { s += 24; }
template <> template <> inline void BinarySize<PropType::None>::Do<atVec4f, Endian::Big>(const PropId& id, atVec4f& var, BinarySize::StreamT& s) { s += 16; }
template <> template <> inline void BinarySize<PropType::None>::Do<atVec4d, Endian::Big>(const PropId& id, atVec4d& var, BinarySize::StreamT& s) { s += 32; }
template <> template <> inline void BinarySize<PropType::None>::Do<bool, Endian::Little>(const PropId& id, bool& var, BinarySize::StreamT& s) { s += 1; }
template <> template <> inline void BinarySize<PropType::None>::Do<atInt8, Endian::Little>(const PropId& id, atInt8& var, BinarySize::StreamT& s) { s += 1; }
template <> template <> inline void BinarySize<PropType::None>::Do<atUint8, Endian::Little>(const PropId& id, atUint8& var, BinarySize::StreamT& s) { s += 1; }
template <> template <> inline void BinarySize<PropType::None>::Do<atInt16, Endian::Little>(const PropId& id, atInt16& var, BinarySize::StreamT& s) { s += 2; }
template <> template <> inline void BinarySize<PropType::None>::Do<atUint16, Endian::Little>(const PropId& id, atUint16& var, BinarySize::StreamT& s) { s += 2; }
template <> template <> inline void BinarySize<PropType::None>::Do<atInt32, Endian::Little>(const PropId& id, atInt32& var, BinarySize::StreamT& s) { s += 4; }
template <> template <> inline void BinarySize<PropType::None>::Do<atUint32, Endian::Little>(const PropId& id, atUint32& var, BinarySize::StreamT& s) { s += 4; }
template <> template <> inline void BinarySize<PropType::None>::Do<atInt64, Endian::Little>(const PropId& id, atInt64& var, BinarySize::StreamT& s) { s += 8; }
template <> template <> inline void BinarySize<PropType::None>::Do<atUint64, Endian::Little>(const PropId& id, atUint64& var, BinarySize::StreamT& s) { s += 8; }
template <> template <> inline void BinarySize<PropType::None>::Do<float, Endian::Little>(const PropId& id, float& var, BinarySize::StreamT& s) { s += 4; }
template <> template <> inline void BinarySize<PropType::None>::Do<double, Endian::Little>(const PropId& id, double& var, BinarySize::StreamT& s) { s += 8; }
template <> template <> inline void BinarySize<PropType::None>::Do<atVec2f, Endian::Little>(const PropId& id, atVec2f& var, BinarySize::StreamT& s) { s += 8; }
template <> template <> inline void BinarySize<PropType::None>::Do<atVec2d, Endian::Little>(const PropId& id, atVec2d& var, BinarySize::StreamT& s) { s += 16; }
template <> template <> inline void BinarySize<PropType::None>::Do<atVec3f, Endian::Little>(const PropId& id, atVec3f& var, BinarySize::StreamT& s) { s += 12; }
template <> template <> inline void BinarySize<PropType::None>::Do<atVec3d, Endian::Little>(const PropId& id, atVec3d& var, BinarySize::StreamT& s) { s += 24; }
template <> template <> inline void BinarySize<PropType::None>::Do<atVec4f, Endian::Little>(const PropId& id, atVec4f& var, BinarySize::StreamT& s) { s += 16; }
template <> template <> inline void BinarySize<PropType::None>::Do<atVec4d, Endian::Little>(const PropId& id, atVec4d& var, BinarySize::StreamT& s) { s += 32; }
template <PropType PropOp>
struct PropCount
{
using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>;
using StreamT = size_t;
template <class T, Endian DNAE>
static void Do(const PropId& id, T& var, StreamT& s)
{
/* Only reports one level of properties */
s += 1;
}
template <class T, Endian DNAE>
static void Do(const PropId& id, std::vector<T>& vector, size_t count, StreamT& s)
{
/* Only reports one level of properties */
s += 1;
}
static void Do(const PropId& id, std::unique_ptr<atUint8[]>& buf, size_t count, StreamT& s)
{
/* Only reports one level of properties */
s += 1;
}
static void Do(const PropId& id, std::string& str, StreamT& s)
{
/* Only reports one level of properties */
s += 1;
}
static void Do(const PropId& id, std::string& str, size_t count, StreamT& s)
{
/* Only reports one level of properties */
s += 1;
}
template <Endian DNAE>
static void Do(const PropId& id, std::wstring& str, StreamT& s)
{
/* Only reports one level of properties */
s += 1;
}
template <Endian DNAE>
static void Do(const PropId& id, std::wstring& str, size_t count, StreamT& s)
{
/* Only reports one level of properties */
s += 1;
}
static void DoSeek(atInt64 amount, SeekOrigin whence, StreamT& s) {}
static void DoAlign(atInt64 amount, StreamT& s) {}
};
template <PropType PropOp>
struct Read
{
using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>;
using StreamT = IStreamReader;
template <class T, Endian DNAE>
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>;
Read<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), r);
}
template <class T, Endian DNAE>
static typename std::enable_if_t<__IsPODType<T>()>
Do(const PropId& id, T& var, StreamT& r)
{
Read<PropType::None>::Do<T, DNAE>(id, var, r);
}
template <class T, Endian DNAE>
static typename std::enable_if_t<!std::is_enum_v<T> && !__IsPODType<T>()>
Do(const PropId& id, T& var, StreamT& r)
{
if (PropOp != PropType::None)
{
/* Accessed via Lookup, no header */
atUint16 propCount = T::DNAEndian == Endian::Big ? r.readUint16Big() : r.readUint16Little();
for (atUint32 i = 0; i < propCount; ++i)
{
atUint64 hash;
if (PropOp == PropType::CRC64)
hash = T::DNAEndian == Endian::Big ? r.readUint64Big() : r.readUint64Little();
else
hash = T::DNAEndian == Endian::Big ? r.readUint32Big() : r.readUint32Little();
atInt64 size = T::DNAEndian == Endian::Big ? r.readUint16Big() : r.readUint16Little();
atInt64 start = r.position();
var.template Lookup<Read<PropOp>>(hash, r);
atInt64 actualRead = r.position() - start;
if (actualRead != size)
r.seek(size - actualRead);
}
}
else
var.template Enumerate<Read<PropOp>>(r);
}
template <class T, Endian DNAE>
static void Do(const PropId& id, std::vector<T>& vector, size_t count, StreamT& r)
{
vector.clear();
vector.reserve(count);
for (size_t i = 0; i < count; ++i)
{
vector.emplace_back();
Read<PropOp>::Do<T, DNAE>(id, vector.back(), r);
}
}
static void Do(const PropId& id, std::unique_ptr<atUint8[]>& buf, size_t count, StreamT& r)
{
buf.reset(new atUint8[count]);
r.readUBytesToBuf(buf.get(), count);
}
static void Do(const PropId& id, std::string& str, StreamT& r)
{
str = r.readString();
}
static void Do(const PropId& id, std::string& str, size_t count, StreamT& r)
{
str = r.readString(count);
}
template <Endian DNAE>
static void Do(const PropId& id, std::wstring& str, StreamT& r)
{
Read<PropType::None>::Do<DNAE>(id, str, r);
}
template <Endian DNAE>
static void Do(const PropId& id, std::wstring& str, size_t count, StreamT& r)
{
Read<PropType::None>::Do<DNAE>(id, str, count, r);
}
static void DoSeek(atInt64 amount, SeekOrigin whence, StreamT& r)
{
r.seek(amount, whence);
}
static void DoAlign(atInt64 amount, StreamT& r)
{
r.seek((r.position() + amount-1) / amount * amount, athena::Begin);
}
};
template <> template <> inline void Read<PropType::None>::Do<bool, Endian::Big>(const PropId& id, bool& var, Read::StreamT& r) { var = r.readBool(); }
template <> template <> inline void Read<PropType::None>::Do<atInt8, Endian::Big>(const PropId& id, atInt8& var, Read::StreamT& r) { var = r.readByte(); }
template <> template <> inline void Read<PropType::None>::Do<atUint8, Endian::Big>(const PropId& id, atUint8& var, Read::StreamT& r) { var = r.readUByte(); }
template <> template <> inline void Read<PropType::None>::Do<atInt16, Endian::Big>(const PropId& id, atInt16& var, Read::StreamT& r) { var = r.readInt16Big(); }
template <> template <> inline void Read<PropType::None>::Do<atUint16, Endian::Big>(const PropId& id, atUint16& var, Read::StreamT& r) { var = r.readUint16Big(); }
template <> template <> inline void Read<PropType::None>::Do<atInt32, Endian::Big>(const PropId& id, atInt32& var, Read::StreamT& r) { var = r.readInt32Big(); }
template <> template <> inline void Read<PropType::None>::Do<atUint32, Endian::Big>(const PropId& id, atUint32& var, Read::StreamT& r) { var = r.readUint32Big(); }
template <> template <> inline void Read<PropType::None>::Do<atInt64, Endian::Big>(const PropId& id, atInt64& var, Read::StreamT& r) { var = r.readInt64Big(); }
template <> template <> inline void Read<PropType::None>::Do<atUint64, Endian::Big>(const PropId& id, atUint64& var, Read::StreamT& r) { var = r.readUint64Big(); }
template <> template <> inline void Read<PropType::None>::Do<float, Endian::Big>(const PropId& id, float& var, Read::StreamT& r) { var = r.readFloatBig(); }
template <> template <> inline void Read<PropType::None>::Do<double, Endian::Big>(const PropId& id, double& var, Read::StreamT& r) { var = r.readDoubleBig(); }
template <> template <> inline void Read<PropType::None>::Do<atVec2f, Endian::Big>(const PropId& id, atVec2f& var, Read::StreamT& r) { var = r.readVec2fBig(); }
template <> template <> inline void Read<PropType::None>::Do<atVec2d, Endian::Big>(const PropId& id, atVec2d& var, Read::StreamT& r) { var = r.readVec2dBig(); }
template <> template <> inline void Read<PropType::None>::Do<atVec3f, Endian::Big>(const PropId& id, atVec3f& var, Read::StreamT& r) { var = r.readVec3fBig(); }
template <> template <> inline void Read<PropType::None>::Do<atVec3d, Endian::Big>(const PropId& id, atVec3d& var, Read::StreamT& r) { var = r.readVec3dBig(); }
template <> template <> inline void Read<PropType::None>::Do<atVec4f, Endian::Big>(const PropId& id, atVec4f& var, Read::StreamT& r) { var = r.readVec4fBig(); }
template <> template <> inline void Read<PropType::None>::Do<atVec4d, Endian::Big>(const PropId& id, atVec4d& var, Read::StreamT& r) { var = r.readVec4dBig(); }
template <> template <> inline void Read<PropType::None>::Do<Endian::Big>(const PropId& id, std::wstring& str, StreamT& r) { str = r.readWStringBig(); }
template <> template <> inline void Read<PropType::None>::Do<Endian::Big>(const PropId& id, std::wstring& str, size_t count, StreamT& r) { str = r.readWStringBig(count); }
template <> template <> inline void Read<PropType::None>::Do<bool, Endian::Little>(const PropId& id, bool& var, Read::StreamT& r) { var = r.readBool(); }
template <> template <> inline void Read<PropType::None>::Do<atInt8, Endian::Little>(const PropId& id, atInt8& var, Read::StreamT& r) { var = r.readByte(); }
template <> template <> inline void Read<PropType::None>::Do<atUint8, Endian::Little>(const PropId& id, atUint8& var, Read::StreamT& r) { var = r.readUByte(); }
template <> template <> inline void Read<PropType::None>::Do<atInt16, Endian::Little>(const PropId& id, atInt16& var, Read::StreamT& r) { var = r.readInt16Little(); }
template <> template <> inline void Read<PropType::None>::Do<atUint16, Endian::Little>(const PropId& id, atUint16& var, Read::StreamT& r) { var = r.readUint16Little(); }
template <> template <> inline void Read<PropType::None>::Do<atInt32, Endian::Little>(const PropId& id, atInt32& var, Read::StreamT& r) { var = r.readInt32Little(); }
template <> template <> inline void Read<PropType::None>::Do<atUint32, Endian::Little>(const PropId& id, atUint32& var, Read::StreamT& r) { var = r.readUint32Little(); }
template <> template <> inline void Read<PropType::None>::Do<atInt64, Endian::Little>(const PropId& id, atInt64& var, Read::StreamT& r) { var = r.readInt64Little(); }
template <> template <> inline void Read<PropType::None>::Do<atUint64, Endian::Little>(const PropId& id, atUint64& var, Read::StreamT& r) { var = r.readUint64Little(); }
template <> template <> inline void Read<PropType::None>::Do<float, Endian::Little>(const PropId& id, float& var, Read::StreamT& r) { var = r.readFloatLittle(); }
template <> template <> inline void Read<PropType::None>::Do<double, Endian::Little>(const PropId& id, double& var, Read::StreamT& r) { var = r.readDoubleLittle(); }
template <> template <> inline void Read<PropType::None>::Do<atVec2f, Endian::Little>(const PropId& id, atVec2f& var, Read::StreamT& r) { var = r.readVec2fLittle(); }
template <> template <> inline void Read<PropType::None>::Do<atVec2d, Endian::Little>(const PropId& id, atVec2d& var, Read::StreamT& r) { var = r.readVec2dLittle(); }
template <> template <> inline void Read<PropType::None>::Do<atVec3f, Endian::Little>(const PropId& id, atVec3f& var, Read::StreamT& r) { var = r.readVec3fLittle(); }
template <> template <> inline void Read<PropType::None>::Do<atVec3d, Endian::Little>(const PropId& id, atVec3d& var, Read::StreamT& r) { var = r.readVec3dLittle(); }
template <> template <> inline void Read<PropType::None>::Do<atVec4f, Endian::Little>(const PropId& id, atVec4f& var, Read::StreamT& r) { var = r.readVec4fLittle(); }
template <> template <> inline void Read<PropType::None>::Do<atVec4d, Endian::Little>(const PropId& id, atVec4d& var, Read::StreamT& r) { var = r.readVec4dLittle(); }
template <> template <> inline void Read<PropType::None>::Do<Endian::Little>(const PropId& id, std::wstring& str, StreamT& r) { str = r.readWStringLittle(); }
template <> template <> inline void Read<PropType::None>::Do<Endian::Little>(const PropId& id, std::wstring& str, size_t count, StreamT& r) { str = r.readWStringLittle(count); }
template <PropType PropOp>
struct Write
{
using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>;
using StreamT = IStreamWriter;
template <class T, Endian DNAE>
static typename std::enable_if_t<std::is_enum_v<T>>
Do(const PropId& id, T& var, StreamT& w)
{
if (PropOp != PropType::None)
{
/* Accessed via Enumerate, header */
if (PropOp == PropType::CRC64)
DNAE == Endian::Big ? w.writeUint64Big(id.crc64) : w.writeUint64Little(id.crc64);
else
DNAE == Endian::Big ? w.writeUint32Big(id.rcrc32) : w.writeUint32Little(id.rcrc32);
size_t binarySize = 0;
BinarySize<PropType::None>::Do<T, DNAE>(id, var, binarySize);
DNAE == Endian::Big ? w.writeUint16Big(atUint16(binarySize)) : w.writeUint16Little(atUint16(binarySize));
}
using PODType = std::underlying_type_t<T>;
Write<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), w);
}
template <class T, Endian DNAE>
static typename std::enable_if_t<__IsPODType<T>()>
Do(const PropId& id, T& var, StreamT& w)
{
if (PropOp != PropType::None)
{
/* Accessed via Enumerate, header */
if (PropOp == PropType::CRC64)
DNAE == Endian::Big ? w.writeUint64Big(id.crc64) : w.writeUint64Little(id.crc64);
else
DNAE == Endian::Big ? w.writeUint32Big(id.rcrc32) : w.writeUint32Little(id.rcrc32);
size_t binarySize = 0;
BinarySize<PropType::None>::Do<T, DNAE>(id, var, binarySize);
DNAE == Endian::Big ? w.writeUint16Big(atUint16(binarySize)) : w.writeUint16Little(atUint16(binarySize));
}
Write<PropType::None>::Do<T, DNAE>(id, var, w);
}
template <class T, Endian DNAE>
static typename std::enable_if_t<!std::is_enum_v<T> && !__IsPODType<T>()>
Do(const PropId& id, T& var, StreamT& w)
{
if (PropOp != PropType::None)
{
/* Accessed via Enumerate, header */
if (PropOp == PropType::CRC64)
T::DNAEndian == Endian::Big ? w.writeUint64Big(id.crc64) : w.writeUint64Little(id.crc64);
else
T::DNAEndian == Endian::Big ? w.writeUint32Big(id.rcrc32) : w.writeUint32Little(id.rcrc32);
size_t binarySize = 0;
var.template Enumerate<BinarySize<PropOp>>(binarySize);
T::DNAEndian == Endian::Big ? w.writeUint16Big(atUint16(binarySize)) : w.writeUint16Little(atUint16(binarySize));
size_t propCount = 0;
var.template Enumerate<PropCount<PropOp>>(propCount);
T::DNAEndian == Endian::Big ? w.writeUint16Big(atUint16(propCount)) : w.writeUint16Little(atUint16(propCount));
var.template Enumerate<Write<PropOp>>(w);
}
else
var.template Enumerate<Write<PropOp>>(w);
}
template <class T, Endian DNAE>
static void Do(const PropId& id, std::vector<T>& vector, size_t count, StreamT& w)
{
for (T& v : vector)
Write<PropOp>::Do<T, DNAE>(id, v, w);
}
static void Do(const PropId& id, std::unique_ptr<atUint8[]>& buf, size_t count, StreamT& w)
{
if (buf)
w.writeUBytes(buf.get(), count);
}
static void Do(const PropId& id, std::string& str, StreamT& w)
{
w.writeString(str);
}
static void Do(const PropId& id, std::string& str, size_t count, StreamT& w)
{
w.writeString(str, count);
}
template <Endian DNAE>
static void Do(const PropId& id, std::wstring& str, StreamT& w)
{
Write<PropType::None>::Do<DNAE>(id, str, w);
}
template <Endian DNAE>
static void Do(const PropId& id, std::wstring& str, size_t count, StreamT& w)
{
Write<PropType::None>::Do<DNAE>(id, str, count, w);
}
static void DoSeek(atInt64 amount, SeekOrigin whence, StreamT& w)
{
w.seek(amount, whence);
}
static void DoAlign(atInt64 amount, StreamT& w)
{
w.writeZeroTo((w.position() + amount-1) / amount * amount);
}
};
template <> template <> inline void Write<PropType::None>::Do<bool, Endian::Big>(const PropId& id, bool& var, Write::StreamT& w) { w.writeBool(var); }
template <> template <> inline void Write<PropType::None>::Do<atInt8, Endian::Big>(const PropId& id, atInt8& var, Write::StreamT& w) { w.writeByte(var); }
template <> template <> inline void Write<PropType::None>::Do<atUint8, Endian::Big>(const PropId& id, atUint8& var, Write::StreamT& w) { w.writeUByte(var); }
template <> template <> inline void Write<PropType::None>::Do<atInt16, Endian::Big>(const PropId& id, atInt16& var, Write::StreamT& w) { w.writeInt16Big(var); }
template <> template <> inline void Write<PropType::None>::Do<atUint16, Endian::Big>(const PropId& id, atUint16& var, Write::StreamT& w) { w.writeUint16Big(var); }
template <> template <> inline void Write<PropType::None>::Do<atInt32, Endian::Big>(const PropId& id, atInt32& var, Write::StreamT& w) { w.writeInt32Big(var); }
template <> template <> inline void Write<PropType::None>::Do<atUint32, Endian::Big>(const PropId& id, atUint32& var, Write::StreamT& w) { w.writeUint32Big(var); }
template <> template <> inline void Write<PropType::None>::Do<atInt64, Endian::Big>(const PropId& id, atInt64& var, Write::StreamT& w) { w.writeInt64Big(var); }
template <> template <> inline void Write<PropType::None>::Do<atUint64, Endian::Big>(const PropId& id, atUint64& var, Write::StreamT& w) { w.writeUint64Big(var); }
template <> template <> inline void Write<PropType::None>::Do<float, Endian::Big>(const PropId& id, float& var, Write::StreamT& w) { w.writeFloatBig(var); }
template <> template <> inline void Write<PropType::None>::Do<double, Endian::Big>(const PropId& id, double& var, Write::StreamT& w) { w.writeDoubleBig(var); }
template <> template <> inline void Write<PropType::None>::Do<atVec2f, Endian::Big>(const PropId& id, atVec2f& var, Write::StreamT& w) { w.writeVec2fBig(var); }
template <> template <> inline void Write<PropType::None>::Do<atVec2d, Endian::Big>(const PropId& id, atVec2d& var, Write::StreamT& w) { w.writeVec2dBig(var); }
template <> template <> inline void Write<PropType::None>::Do<atVec3f, Endian::Big>(const PropId& id, atVec3f& var, Write::StreamT& w) { w.writeVec3fBig(var); }
template <> template <> inline void Write<PropType::None>::Do<atVec3d, Endian::Big>(const PropId& id, atVec3d& var, Write::StreamT& w) { w.writeVec3dBig(var); }
template <> template <> inline void Write<PropType::None>::Do<atVec4f, Endian::Big>(const PropId& id, atVec4f& var, Write::StreamT& w) { w.writeVec4fBig(var); }
template <> template <> inline void Write<PropType::None>::Do<atVec4d, Endian::Big>(const PropId& id, atVec4d& var, Write::StreamT& w) { w.writeVec4dBig(var); }
template <> template <> inline void Write<PropType::None>::Do<Endian::Big>(const PropId& id, std::wstring& str, StreamT& w) { w.writeWStringBig(str); }
template <> template <> inline void Write<PropType::None>::Do<Endian::Big>(const PropId& id, std::wstring& str, size_t count, StreamT& w) { w.writeWStringBig(str, count); }
template <> template <> inline void Write<PropType::None>::Do<bool, Endian::Little>(const PropId& id, bool& var, Write::StreamT& w) { w.writeBool(var); }
template <> template <> inline void Write<PropType::None>::Do<atInt8, Endian::Little>(const PropId& id, atInt8& var, Write::StreamT& w) { w.writeByte(var); }
template <> template <> inline void Write<PropType::None>::Do<atUint8, Endian::Little>(const PropId& id, atUint8& var, Write::StreamT& w) { w.writeUByte(var); }
template <> template <> inline void Write<PropType::None>::Do<atInt16, Endian::Little>(const PropId& id, atInt16& var, Write::StreamT& w) { w.writeInt16Little(var); }
template <> template <> inline void Write<PropType::None>::Do<atUint16, Endian::Little>(const PropId& id, atUint16& var, Write::StreamT& w) { w.writeUint16Little(var); }
template <> template <> inline void Write<PropType::None>::Do<atInt32, Endian::Little>(const PropId& id, atInt32& var, Write::StreamT& w) { w.writeInt32Little(var); }
template <> template <> inline void Write<PropType::None>::Do<atUint32, Endian::Little>(const PropId& id, atUint32& var, Write::StreamT& w) { w.writeUint32Little(var); }
template <> template <> inline void Write<PropType::None>::Do<atInt64, Endian::Little>(const PropId& id, atInt64& var, Write::StreamT& w) { w.writeInt64Little(var); }
template <> template <> inline void Write<PropType::None>::Do<atUint64, Endian::Little>(const PropId& id, atUint64& var, Write::StreamT& w) { w.writeUint64Little(var); }
template <> template <> inline void Write<PropType::None>::Do<float, Endian::Little>(const PropId& id, float& var, Write::StreamT& w) { w.writeFloatLittle(var); }
template <> template <> inline void Write<PropType::None>::Do<double, Endian::Little>(const PropId& id, double& var, Write::StreamT& w) { w.writeDoubleLittle(var); }
template <> template <> inline void Write<PropType::None>::Do<atVec2f, Endian::Little>(const PropId& id, atVec2f& var, Write::StreamT& w) { w.writeVec2fLittle(var); }
template <> template <> inline void Write<PropType::None>::Do<atVec2d, Endian::Little>(const PropId& id, atVec2d& var, Write::StreamT& w) { w.writeVec2dLittle(var); }
template <> template <> inline void Write<PropType::None>::Do<atVec3f, Endian::Little>(const PropId& id, atVec3f& var, Write::StreamT& w) { w.writeVec3fLittle(var); }
template <> template <> inline void Write<PropType::None>::Do<atVec3d, Endian::Little>(const PropId& id, atVec3d& var, Write::StreamT& w) { w.writeVec3dLittle(var); }
template <> template <> inline void Write<PropType::None>::Do<atVec4f, Endian::Little>(const PropId& id, atVec4f& var, Write::StreamT& w) { w.writeVec4fLittle(var); }
template <> template <> inline void Write<PropType::None>::Do<atVec4d, Endian::Little>(const PropId& id, atVec4d& var, Write::StreamT& w) { w.writeVec4dLittle(var); }
template <> template <> inline void Write<PropType::None>::Do<Endian::Little>(const PropId& id, std::wstring& str, StreamT& w) { w.writeWStringLittle(str); }
template <> template <> inline void Write<PropType::None>::Do<Endian::Little>(const PropId& id, std::wstring& str, size_t count, StreamT& w) { w.writeWStringLittle(str, count); }
template <PropType PropOp>
struct ReadYaml
{
using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>;
using StreamT = YAMLDocReader;
template <class T, Endian DNAE>
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>;
ReadYaml<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), r);
}
template <class T, Endian DNAE>
static typename std::enable_if_t<__IsPODType<T>()>
Do(const PropId& id, T& var, StreamT& r)
{
ReadYaml<PropType::None>::Do<T, DNAE>(id, var, r);
}
template <class T, Endian DNAE>
static typename std::enable_if_t<!std::is_enum_v<T> && !__IsPODType<T>()>
Do(const PropId& id, T& var, StreamT& r)
{
if (auto rec = r.enterSubRecord(id.name))
var.template Enumerate<ReadYaml<PropOp>>(r);
}
template <class T, Endian DNAE>
static void Do(const PropId& id, std::vector<T>& vector, size_t count, StreamT& r)
{
vector.clear();
vector.reserve(count);
for (size_t i = 0; i < count; ++i)
{
vector.emplace_back();
ReadYaml<PropOp>::Do<T, DNAE>(id, vector.back(), r);
}
}
static void Do(const PropId& id, std::unique_ptr<atUint8[]>& buf, size_t count, StreamT& r)
{
buf = r.readUBytes(id.name);
}
static void Do(const PropId& id, std::string& str, StreamT& r)
{
str = r.readString(id.name);
}
static void Do(const PropId& id, std::string& str, size_t count, StreamT& r)
{
str = r.readString(id.name);
}
template <Endian DNAE>
static void Do(const PropId& id, std::wstring& str, StreamT& r)
{
str = r.readWString(id.name);
}
template <Endian DNAE>
static void Do(const PropId& id, std::wstring& str, size_t count, StreamT& r)
{
str = r.readWString(id.name);
}
static void DoSeek(atInt64 amount, SeekOrigin whence, StreamT& r) {}
static void DoAlign(atInt64 amount, StreamT& r) {}
};
template <> template <> inline void ReadYaml<PropType::None>::Do<bool, Endian::Big>(const PropId& id, bool& var, ReadYaml::StreamT& r) { var = r.readBool(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atInt8, Endian::Big>(const PropId& id, atInt8& var, ReadYaml::StreamT& r) { var = r.readByte(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atUint8, Endian::Big>(const PropId& id, atUint8& var, ReadYaml::StreamT& r) { var = r.readUByte(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atInt16, Endian::Big>(const PropId& id, atInt16& var, ReadYaml::StreamT& r) { var = r.readInt16(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atUint16, Endian::Big>(const PropId& id, atUint16& var, ReadYaml::StreamT& r) { var = r.readUint16(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atInt32, Endian::Big>(const PropId& id, atInt32& var, ReadYaml::StreamT& r) { var = r.readInt32(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atUint32, Endian::Big>(const PropId& id, atUint32& var, ReadYaml::StreamT& r) { var = r.readUint32(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atInt64, Endian::Big>(const PropId& id, atInt64& var, ReadYaml::StreamT& r) { var = r.readInt64(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atUint64, Endian::Big>(const PropId& id, atUint64& var, ReadYaml::StreamT& r) { var = r.readUint64(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<float, Endian::Big>(const PropId& id, float& var, ReadYaml::StreamT& r) { var = r.readFloat(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<double, Endian::Big>(const PropId& id, double& var, ReadYaml::StreamT& r) { var = r.readDouble(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atVec2f, Endian::Big>(const PropId& id, atVec2f& var, ReadYaml::StreamT& r) { var = r.readVec2f(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atVec2d, Endian::Big>(const PropId& id, atVec2d& var, ReadYaml::StreamT& r) { var = r.readVec2d(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atVec3f, Endian::Big>(const PropId& id, atVec3f& var, ReadYaml::StreamT& r) { var = r.readVec3f(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atVec3d, Endian::Big>(const PropId& id, atVec3d& var, ReadYaml::StreamT& r) { var = r.readVec3d(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atVec4f, Endian::Big>(const PropId& id, atVec4f& var, ReadYaml::StreamT& r) { var = r.readVec4f(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atVec4d, Endian::Big>(const PropId& id, atVec4d& var, ReadYaml::StreamT& r) { var = r.readVec4d(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<bool, Endian::Little>(const PropId& id, bool& var, ReadYaml::StreamT& r) { var = r.readBool(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atInt8, Endian::Little>(const PropId& id, atInt8& var, ReadYaml::StreamT& r) { var = r.readByte(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atUint8, Endian::Little>(const PropId& id, atUint8& var, ReadYaml::StreamT& r) { var = r.readUByte(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atInt16, Endian::Little>(const PropId& id, atInt16& var, ReadYaml::StreamT& r) { var = r.readInt16(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atUint16, Endian::Little>(const PropId& id, atUint16& var, ReadYaml::StreamT& r) { var = r.readUint16(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atInt32, Endian::Little>(const PropId& id, atInt32& var, ReadYaml::StreamT& r) { var = r.readInt32(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atUint32, Endian::Little>(const PropId& id, atUint32& var, ReadYaml::StreamT& r) { var = r.readUint32(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atInt64, Endian::Little>(const PropId& id, atInt64& var, ReadYaml::StreamT& r) { var = r.readInt64(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atUint64, Endian::Little>(const PropId& id, atUint64& var, ReadYaml::StreamT& r) { var = r.readUint64(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<float, Endian::Little>(const PropId& id, float& var, ReadYaml::StreamT& r) { var = r.readFloat(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<double, Endian::Little>(const PropId& id, double& var, ReadYaml::StreamT& r) { var = r.readDouble(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atVec2f, Endian::Little>(const PropId& id, atVec2f& var, ReadYaml::StreamT& r) { var = r.readVec2f(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atVec2d, Endian::Little>(const PropId& id, atVec2d& var, ReadYaml::StreamT& r) { var = r.readVec2d(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atVec3f, Endian::Little>(const PropId& id, atVec3f& var, ReadYaml::StreamT& r) { var = r.readVec3f(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atVec3d, Endian::Little>(const PropId& id, atVec3d& var, ReadYaml::StreamT& r) { var = r.readVec3d(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atVec4f, Endian::Little>(const PropId& id, atVec4f& var, ReadYaml::StreamT& r) { var = r.readVec4f(id.name); }
template <> template <> inline void ReadYaml<PropType::None>::Do<atVec4d, Endian::Little>(const PropId& id, atVec4d& var, ReadYaml::StreamT& r) { var = r.readVec4d(id.name); }
template <PropType PropOp>
struct WriteYaml
{
using PropT = std::conditional_t<PropOp == PropType::CRC64, uint64_t, uint32_t>;
using StreamT = YAMLDocWriter;
template <class T, Endian DNAE>
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>;
WriteYaml<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), w);
}
template <class T, Endian DNAE>
static typename std::enable_if_t<__IsPODType<T>()>
Do(const PropId& id, T& var, StreamT& w)
{
WriteYaml<PropType::None>::Do<T, DNAE>(id, var, w);
}
template <class T, Endian DNAE>
static typename std::enable_if_t<!std::is_enum_v<T> && !__IsPODType<T>()>
Do(const PropId& id, T& var, StreamT& w)
{
if (auto rec = w.enterSubRecord(id.name))
var.template Enumerate<WriteYaml<PropOp>>(w);
}
template <class T, Endian DNAE>
static void Do(const PropId& id, std::vector<T>& vector, size_t count, StreamT& w)
{
for (T& v : vector)
WriteYaml<PropOp>::Do<T, DNAE>(id, v, w);
}
static void Do(const PropId& id, std::unique_ptr<atUint8[]>& buf, size_t count, StreamT& w)
{
w.writeUBytes(id.name, buf, count);
}
static void Do(const PropId& id, std::string& str, StreamT& w)
{
w.writeString(id.name, str);
}
static void Do(const PropId& id, std::string& str, size_t count, StreamT& w)
{
w.writeString(id.name, str);
}
template <Endian DNAE>
static void Do(const PropId& id, std::wstring& str, StreamT& w)
{
w.writeWString(id.name, str);
}
template <Endian DNAE>
static void Do(const PropId& id, std::wstring& str, size_t count, StreamT& w)
{
w.writeWString(id.name, str);
}
static void DoSeek(atInt64 amount, SeekOrigin whence, StreamT& w) {}
static void DoAlign(atInt64 amount, StreamT& w) {}
};
template <> template <> inline void WriteYaml<PropType::None>::Do<bool, Endian::Big>(const PropId& id, bool& var, WriteYaml::StreamT& w) { w.writeBool(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atInt8, Endian::Big>(const PropId& id, atInt8& var, WriteYaml::StreamT& w) { w.writeByte(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atUint8, Endian::Big>(const PropId& id, atUint8& var, WriteYaml::StreamT& w) { w.writeUByte(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atInt16, Endian::Big>(const PropId& id, atInt16& var, WriteYaml::StreamT& w) { w.writeInt16(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atUint16, Endian::Big>(const PropId& id, atUint16& var, WriteYaml::StreamT& w) { w.writeUint16(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atInt32, Endian::Big>(const PropId& id, atInt32& var, WriteYaml::StreamT& w) { w.writeInt32(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atUint32, Endian::Big>(const PropId& id, atUint32& var, WriteYaml::StreamT& w) { w.writeUint32(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atInt64, Endian::Big>(const PropId& id, atInt64& var, WriteYaml::StreamT& w) { w.writeInt64(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atUint64, Endian::Big>(const PropId& id, atUint64& var, WriteYaml::StreamT& w) { w.writeUint64(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<float, Endian::Big>(const PropId& id, float& var, WriteYaml::StreamT& w) { w.writeFloat(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<double, Endian::Big>(const PropId& id, double& var, WriteYaml::StreamT& w) { w.writeDouble(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atVec2f, Endian::Big>(const PropId& id, atVec2f& var, WriteYaml::StreamT& w) { w.writeVec2f(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atVec2d, Endian::Big>(const PropId& id, atVec2d& var, WriteYaml::StreamT& w) { w.writeVec2d(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atVec3f, Endian::Big>(const PropId& id, atVec3f& var, WriteYaml::StreamT& w) { w.writeVec3f(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atVec3d, Endian::Big>(const PropId& id, atVec3d& var, WriteYaml::StreamT& w) { w.writeVec3d(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atVec4f, Endian::Big>(const PropId& id, atVec4f& var, WriteYaml::StreamT& w) { w.writeVec4f(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atVec4d, Endian::Big>(const PropId& id, atVec4d& var, WriteYaml::StreamT& w) { w.writeVec4d(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<bool, Endian::Little>(const PropId& id, bool& var, WriteYaml::StreamT& w) { w.writeBool(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atInt8, Endian::Little>(const PropId& id, atInt8& var, WriteYaml::StreamT& w) { w.writeByte(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atUint8, Endian::Little>(const PropId& id, atUint8& var, WriteYaml::StreamT& w) { w.writeUByte(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atInt16, Endian::Little>(const PropId& id, atInt16& var, WriteYaml::StreamT& w) { w.writeInt16(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atUint16, Endian::Little>(const PropId& id, atUint16& var, WriteYaml::StreamT& w) { w.writeUint16(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atInt32, Endian::Little>(const PropId& id, atInt32& var, WriteYaml::StreamT& w) { w.writeInt32(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atUint32, Endian::Little>(const PropId& id, atUint32& var, WriteYaml::StreamT& w) { w.writeUint32(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atInt64, Endian::Little>(const PropId& id, atInt64& var, WriteYaml::StreamT& w) { w.writeInt64(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atUint64, Endian::Little>(const PropId& id, atUint64& var, WriteYaml::StreamT& w) { w.writeUint64(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<float, Endian::Little>(const PropId& id, float& var, WriteYaml::StreamT& w) { w.writeFloat(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<double, Endian::Little>(const PropId& id, double& var, WriteYaml::StreamT& w) { w.writeDouble(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atVec2f, Endian::Little>(const PropId& id, atVec2f& var, WriteYaml::StreamT& w) { w.writeVec2f(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atVec2d, Endian::Little>(const PropId& id, atVec2d& var, WriteYaml::StreamT& w) { w.writeVec2d(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atVec3f, Endian::Little>(const PropId& id, atVec3f& var, WriteYaml::StreamT& w) { w.writeVec3f(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atVec3d, Endian::Little>(const PropId& id, atVec3d& var, WriteYaml::StreamT& w) { w.writeVec3d(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atVec4f, Endian::Little>(const PropId& id, atVec4f& var, WriteYaml::StreamT& w) { w.writeVec4f(id.name, var); }
template <> template <> inline void WriteYaml<PropType::None>::Do<atVec4d, Endian::Little>(const PropId& id, atVec4d& var, WriteYaml::StreamT& w) { w.writeVec4d(id.name, var); }
template <class Op, class T, Endian DNAE>
static inline void __Do(const PropId& id, T& var, typename Op::StreamT& s)
{
Op::template Do<T, DNAE>(id, var, s);
}
template <class Op, class T, Endian DNAE>
static inline void __Do(const PropId& id, std::vector<T>& vector, size_t count, typename Op::StreamT& s)
{
Op::template Do<T, DNAE>(id, vector, count, s);
}
template <class Op>
static inline void __Do(const PropId& id, std::unique_ptr<atUint8[]>& buf, size_t count, typename Op::StreamT& s)
{
Op::Do(id, buf, count, s);
}
template <class Op>
static inline void __Do(const PropId& id, std::string& str, typename Op::StreamT& s)
{
Op::Do(id, str, s);
}
template <class Op>
static inline void __Do(const PropId& id, std::string& str, size_t count, typename Op::StreamT& s)
{
Op::Do(id, str, count, s);
}
template <class Op, Endian DNAE>
static inline void __Do(const PropId& id, std::wstring& str, typename Op::StreamT& s)
{
Op::template Do<DNAE>(id, str, s);
}
template <class Op, Endian DNAE>
static inline void __Do(const PropId& id, std::wstring& str, size_t count, typename Op::StreamT& s)
{
Op::template Do<DNAE>(id, str, count, s);
}
template <class Op>
static inline void __DoSeek(atInt64 delta, athena::SeekOrigin whence, typename Op::StreamT& s)
{
Op::DoSeek(delta, whence, s);
}
template <class Op>
static inline void __DoAlign(atInt64 amount, typename Op::StreamT& s)
{
Op::DoAlign(amount, s);
}
template <class T>
static inline void __Read(T& obj, athena::io::IStreamReader& r)
{
__Do<Read<PropType::None>, T, T::DNAEndian>({}, obj, r);
}
template <class T>
static inline void __Write(const T& obj, athena::io::IStreamWriter& w)
{
__Do<Write<PropType::None>, T, T::DNAEndian>({}, const_cast<T&>(obj), w);
}
template <class T>
static inline void __BinarySize(const T& obj, size_t& s)
{
__Do<BinarySize<PropType::None>, T, T::DNAEndian>({}, const_cast<T&>(obj), s);
}
template <class T>
static inline void __PropCount(const T& obj, size_t& s)
{
const_cast<T&>(obj).template Enumerate<PropCount<PropType::None>>(s);
}
template <class T>
static inline void __ReadYaml(T& obj, athena::io::YAMLDocReader& r)
{
obj.template Enumerate<ReadYaml<PropType::None>>(r);
}
template <class T>
static inline void __WriteYaml(const T& obj, athena::io::YAMLDocWriter& w)
{
const_cast<T&>(obj).template Enumerate<WriteYaml<PropType::None>>(w);
}
template <class T>
static inline void __ReadProp(T& obj, athena::io::IStreamReader& r)
{
/* Read root 0xffffffff hash (hashed empty string) */
atUint32 hash = T::DNAEndian == Endian::Big ? r.readUint32Big() : r.readUint32Little();
atInt64 size = T::DNAEndian == Endian::Big ? r.readUint16Big() : r.readUint16Little();
atInt64 start = r.position();
__Do<Read<PropType::CRC32>, T, T::DNAEndian>({}, obj, r);
atInt64 actualRead = r.position() - start;
if (actualRead != size)
r.seek(size - actualRead);
}
template <class T>
static inline void __WriteProp(const T& obj, athena::io::IStreamWriter& w)
{
__Do<Write<PropType::CRC32>, T, T::DNAEndian>({}, const_cast<T&>(obj), w);
}
template <class T>
static inline void __BinarySizeProp(const T& obj, size_t& s)
{
__Do<BinarySize<PropType::CRC32>, T, T::DNAEndian>({}, const_cast<T&>(obj), s);
}
template <class T>
static inline void __ReadProp64(T& obj, athena::io::IStreamReader& r)
{
/* Read root 0x0 hash (hashed empty string) */
atUint64 hash = T::DNAEndian == Endian::Big ? r.readUint64Big() : r.readUint64Little();
atInt64 size = T::DNAEndian == Endian::Big ? r.readUint16Big() : r.readUint16Little();
atInt64 start = r.position();
__Do<Read<PropType::CRC64>, T, T::DNAEndian>({}, obj, r);
atInt64 actualRead = r.position() - start;
if (actualRead != size)
r.seek(size - actualRead);
}
template <class T>
static inline void __WriteProp64(const T& obj, athena::io::IStreamWriter& w)
{
__Do<Write<PropType::CRC64>, T, T::DNAEndian>({}, const_cast<T&>(obj), w);
}
template <class T>
static inline void __BinarySizeProp64(const T& obj, size_t& s)
{
__Do<BinarySize<PropType::CRC64>, T, T::DNAEndian>({}, const_cast<T&>(obj), s);
}
}
#define AT_DECL_DNA \
template <class Op, athena::Endian DNAE = DNAEndian, class T> \
void Do(const athena::io::PropId& id, T& var, typename Op::StreamT& s) { athena::io::__Do<Op, T, DNAE>(id, var, s); } \
template <class Op, athena::Endian DNAE = DNAEndian, class T> \
void Do(const athena::io::PropId& id, std::vector<T>& var, size_t count, typename Op::StreamT& s) { athena::io::__Do<Op, T, DNAE>(id, var, count, s); } \
template <class Op> \
void Do(const athena::io::PropId& id, std::unique_ptr<atUint8[]>& buf, size_t count, typename Op::StreamT& s) { athena::io::__Do<Op>(id, buf, count, s); } \
template <class Op> \
void Do(const athena::io::PropId& id, std::string& str, typename Op::StreamT& s) { athena::io::__Do<Op>(id, str, s); } \
template <class Op> \
void Do(const athena::io::PropId& id, std::string& str, size_t count, typename Op::StreamT& s) { athena::io::__Do<Op>(id, str, count, s); } \
template <class Op, athena::Endian DNAE = DNAEndian> \
void Do(const athena::io::PropId& id, std::wstring& str, typename Op::StreamT& s) { athena::io::__Do<Op, DNAE>(id, str, s); } \
template <class Op, athena::Endian DNAE = DNAEndian> \
void Do(const athena::io::PropId& id, std::wstring& str, size_t count, typename Op::StreamT& s) { athena::io::__Do<Op, DNAE>(id, str, count, s); } \
template <class Op> \
void DoSeek(atInt64 delta, athena::SeekOrigin whence, typename Op::StreamT& s) { athena::io::__DoSeek<Op>(delta, whence, s); } \
template <class Op> \
void DoAlign(atInt64 amount, typename Op::StreamT& s) { athena::io::__DoAlign<Op>(amount, s); } \
template <class Op> \
void Enumerate(typename Op::StreamT& s); \
template <class Op> \
bool Lookup(uint64_t hash, typename Op::StreamT& s); \
void read(athena::io::IStreamReader& r) { athena::io::__Read(*this, r); } \
void write(athena::io::IStreamWriter& w) const { athena::io::__Write(*this, w); } \
void binarySize(size_t& s) const { athena::io::__BinarySize(*this, s); } \
void read(athena::io::YAMLDocReader& r) { athena::io::__ReadYaml(*this, r); } \
void write(athena::io::YAMLDocWriter& w) const { athena::io::__WriteYaml(*this, w); } \
void readProp(athena::io::IStreamReader& r) { athena::io::__ReadProp(*this, r); } \
void writeProp(athena::io::IStreamWriter& w) const { athena::io::__WriteProp(*this, w); } \
void binarySizeProp(size_t& s) const { athena::io::__BinarySizeProp(*this, s); } \
void propCount(size_t& s) const { athena::io::__PropCount(*this, s); } \
void readProp64(athena::io::IStreamReader& r) { athena::io::__ReadProp64(*this, r); } \
void writeProp64(athena::io::IStreamWriter& w) const { athena::io::__WriteProp64(*this, w); } \
void binarySizeProp64(size_t& s) const { athena::io::__BinarySizeProp64(*this, s); } \
#define AT_SPECIALIZE_DNA(__Type) \
template void __Type::Enumerate<athena::io::Read<athena::io::PropType::None>>(athena::io::Read<athena::io::PropType::None>::StreamT& s); \
template void __Type::Enumerate<athena::io::Write<athena::io::PropType::None>>(athena::io::Write<athena::io::PropType::None>::StreamT& s); \
template void __Type::Enumerate<athena::io::BinarySize<athena::io::PropType::None>>(athena::io::BinarySize<athena::io::PropType::None>::StreamT& s); \
template void __Type::Enumerate<athena::io::ReadYaml<athena::io::PropType::None>>(athena::io::ReadYaml<athena::io::PropType::None>::StreamT& s); \
template void __Type::Enumerate<athena::io::WriteYaml<athena::io::PropType::None>>(athena::io::WriteYaml<athena::io::PropType::None>::StreamT& s); \
template bool __Type::Lookup<athena::io::Read<athena::io::PropType::CRC32>>(uint64_t hash, athena::io::Read<athena::io::PropType::CRC32>::StreamT& s); \
template void __Type::Enumerate<athena::io::Read<athena::io::PropType::CRC32>>(athena::io::Read<athena::io::PropType::CRC32>::StreamT& s); \
template bool __Type::Lookup<athena::io::Write<athena::io::PropType::CRC32>>(uint64_t hash, athena::io::Write<athena::io::PropType::CRC32>::StreamT& s); \
template void __Type::Enumerate<athena::io::Write<athena::io::PropType::CRC32>>(athena::io::Write<athena::io::PropType::CRC32>::StreamT& s); \
template bool __Type::Lookup<athena::io::BinarySize<athena::io::PropType::CRC32>>(uint64_t hash, athena::io::BinarySize<athena::io::PropType::CRC32>::StreamT& s); \
template void __Type::Enumerate<athena::io::BinarySize<athena::io::PropType::CRC32>>(athena::io::BinarySize<athena::io::PropType::CRC32>::StreamT& s); \
template bool __Type::Lookup<athena::io::PropCount<athena::io::PropType::CRC32>>(uint64_t hash, athena::io::PropCount<athena::io::PropType::CRC32>::StreamT& s); \
template void __Type::Enumerate<athena::io::PropCount<athena::io::PropType::CRC32>>(athena::io::PropCount<athena::io::PropType::CRC32>::StreamT& s); \
template bool __Type::Lookup<athena::io::ReadYaml<athena::io::PropType::CRC32>>(uint64_t hash, athena::io::ReadYaml<athena::io::PropType::CRC32>::StreamT& s); \
template void __Type::Enumerate<athena::io::ReadYaml<athena::io::PropType::CRC32>>(athena::io::ReadYaml<athena::io::PropType::CRC32>::StreamT& s); \
template bool __Type::Lookup<athena::io::WriteYaml<athena::io::PropType::CRC32>>(uint64_t hash, athena::io::WriteYaml<athena::io::PropType::CRC32>::StreamT& s); \
template void __Type::Enumerate<athena::io::WriteYaml<athena::io::PropType::CRC32>>(athena::io::WriteYaml<athena::io::PropType::CRC32>::StreamT& s); \
template bool __Type::Lookup<athena::io::Read<athena::io::PropType::CRC64>>(uint64_t hash, athena::io::Read<athena::io::PropType::CRC64>::StreamT& s); \
template void __Type::Enumerate<athena::io::Read<athena::io::PropType::CRC64>>(athena::io::Read<athena::io::PropType::CRC64>::StreamT& s); \
template bool __Type::Lookup<athena::io::Write<athena::io::PropType::CRC64>>(uint64_t hash, athena::io::Write<athena::io::PropType::CRC64>::StreamT& s); \
template void __Type::Enumerate<athena::io::Write<athena::io::PropType::CRC64>>(athena::io::Write<athena::io::PropType::CRC64>::StreamT& s); \
template bool __Type::Lookup<athena::io::BinarySize<athena::io::PropType::CRC64>>(uint64_t hash, athena::io::BinarySize<athena::io::PropType::CRC64>::StreamT& s); \
template void __Type::Enumerate<athena::io::BinarySize<athena::io::PropType::CRC64>>(athena::io::BinarySize<athena::io::PropType::CRC64>::StreamT& s); \
template bool __Type::Lookup<athena::io::PropCount<athena::io::PropType::CRC64>>(uint64_t hash, athena::io::PropCount<athena::io::PropType::CRC64>::StreamT& s); \
template void __Type::Enumerate<athena::io::PropCount<athena::io::PropType::CRC64>>(athena::io::PropCount<athena::io::PropType::CRC64>::StreamT& s); \
template bool __Type::Lookup<athena::io::ReadYaml<athena::io::PropType::CRC64>>(uint64_t hash, athena::io::ReadYaml<athena::io::PropType::CRC64>::StreamT& s); \
template void __Type::Enumerate<athena::io::ReadYaml<athena::io::PropType::CRC64>>(athena::io::ReadYaml<athena::io::PropType::CRC64>::StreamT& s); \
template bool __Type::Lookup<athena::io::WriteYaml<athena::io::PropType::CRC64>>(uint64_t hash, athena::io::WriteYaml<athena::io::PropType::CRC64>::StreamT& s); \
template void __Type::Enumerate<athena::io::WriteYaml<athena::io::PropType::CRC64>>(athena::io::WriteYaml<athena::io::PropType::CRC64>::StreamT& s);
using namespace athena::io::literals;
#endif // AT_OP_HPP

787
include/athena/DNAYaml.hpp
View File

@ -1,15 +1,8 @@
#ifndef DNAYAML_HPP #ifndef DNAYAML_HPP
#define DNAYAML_HPP #define DNAYAML_HPP
/* BIG FAT WARNING!!! #include "YAMLDocReader.hpp"
* #include "YAMLDocWriter.hpp"
* The type-structure of this file is expected to remain consistent for 'atdna'
* Any changes to the types or namespacing must be reflected in 'atdna/main.cpp'
*/
#include <cstring>
#include <yaml.h>
#include <utf8proc.h>
#include "DNA.hpp" #include "DNA.hpp"
#include "FileReader.hpp" #include "FileReader.hpp"
#include "FileWriter.hpp" #include "FileWriter.hpp"
@ -17,713 +10,115 @@
namespace athena::io namespace athena::io
{ {
enum class YAMLNodeStyle template <class T>
static inline std::string ToYAMLString(const T& dna)
{ {
Any, YAMLDocWriter docWriter(dna.DNAType());
Flow,
Block
};
struct YAMLNode std::string res;
yaml_emitter_set_output(docWriter.getEmitter(), (yaml_write_handler_t*)YAMLStdStringWriter, &res);
yaml_emitter_set_unicode(docWriter.getEmitter(), true);
yaml_emitter_set_width(docWriter.getEmitter(), -1);
dna.write(docWriter);
if (!docWriter.finish(nullptr))
return std::string();
return res;
}
template <class T>
static inline bool FromYAMLString(T& dna, std::string_view str)
{ {
yaml_node_type_t m_type; YAMLStdStringViewReaderState reader(str);
std::string m_scalarString; YAMLDocReader docReader;
std::vector<std::unique_ptr<YAMLNode>> m_seqChildren; yaml_parser_set_input(docReader.getParser(), (yaml_read_handler_t*)YAMLStdStringReader, &reader);
std::vector<std::pair<std::string, std::unique_ptr<YAMLNode>>> m_mapChildren; if (!docReader.parse(nullptr))
YAMLNodeStyle m_style = YAMLNodeStyle::Any;
YAMLNode(yaml_node_type_t type) : m_type(type) {}
inline const YAMLNode* findMapChild(std::string_view key) const
{
for (const auto& item : m_mapChildren)
if (!item.first.compare(key))
return item.second.get();
return nullptr;
}
inline void assignMapChild(std::string_view key, std::unique_ptr<YAMLNode>&& node)
{
for (auto& item : m_mapChildren)
if (!item.first.compare(key))
{
item.second = std::move(node);
return;
}
m_mapChildren.emplace_back(key, std::move(node));
}
};
template <typename RETURNTYPE>
RETURNTYPE NodeToVal(const YAMLNode* node);
template <>
bool NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(bool val);
template <>
atInt8 NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(atInt8 val);
template <>
atUint8 NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(atUint8 val);
template <>
atInt16 NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(atInt16 val);
template <>
atUint16 NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(atUint16 val);
template <>
atInt32 NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(atInt32 val);
template <>
atUint32 NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(atUint32 val);
template <>
atInt64 NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(atInt64 val);
template <>
atUint64 NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(atUint64 val);
template <>
float NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(float val);
template <>
double NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(double val);
template <typename RETURNTYPE>
RETURNTYPE NodeToVec(const YAMLNode* node);
template <>
atVec2f NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(const atVec2f& val);
template <>
atVec3f NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(const atVec3f& val);
template <>
atVec4f NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(const atVec4f& val);
template <>
atVec2d NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(const atVec2d& val);
template <>
atVec3d NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(const atVec3d& val);
template <>
atVec4d NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(const atVec4d& val);
template <>
std::unique_ptr<atUint8[]> NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(const std::unique_ptr<atUint8[]>& val, size_t byteCount);
template <>
std::string NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(std::string_view val);
template <>
std::wstring NodeToVal(const YAMLNode* node);
std::unique_ptr<YAMLNode> ValToNode(std::wstring_view val);
std::unique_ptr<YAMLNode> ValToNode(std::u16string_view val);
std::unique_ptr<YAMLNode> ValToNode(std::u32string_view val);
std::string base64_encode(const atUint8* bytes_to_encode, size_t in_len);
std::unique_ptr<atUint8[]> base64_decode(std::string_view encoded_string);
void HandleYAMLParserError(yaml_parser_t* parser);
void HandleYAMLEmitterError(yaml_emitter_t* emitter);
struct YAMLStdStringViewReaderState
{
std::string_view::const_iterator begin;
std::string_view::const_iterator end;
YAMLStdStringViewReaderState(std::string_view str)
{
begin = str.begin();
end = str.end();
}
};
int YAMLStdStringReader(YAMLStdStringViewReaderState* str,
unsigned char* buffer, size_t size, size_t* size_read);
int YAMLStdStringWriter(std::string* str, unsigned char* buffer, size_t size);
class YAMLDocReader
{
std::unique_ptr<YAMLNode> m_rootNode;
std::vector<YAMLNode*> m_subStack;
std::vector<int> m_seqTrackerStack;
yaml_parser_t m_parser;
std::unique_ptr<YAMLNode> ParseEvents(athena::io::IStreamReader* reader);
void _leaveSubRecord();
void _leaveSubVector();
public:
YAMLDocReader();
~YAMLDocReader();
void reset();
inline yaml_parser_t* getParser() { return &m_parser; }
bool parse(athena::io::IStreamReader* reader);
bool ClassTypeOperation(std::function<bool(const char* dnaType)> func);
bool ValidateClassType(const char* expectedType);
inline const YAMLNode* getRootNode() const { return m_rootNode.get(); }
inline const YAMLNode* getCurNode() const { return m_subStack.empty() ? nullptr : m_subStack.back(); }
std::unique_ptr<YAMLNode> releaseRootNode() { return std::move(m_rootNode); }
class RecordRAII
{
friend class YAMLDocReader;
YAMLDocReader* m_r = nullptr;
RecordRAII(YAMLDocReader* r) : m_r(r) {}
RecordRAII() = default;
public:
operator bool() const { return m_r != nullptr; }
~RecordRAII() { if (m_r) m_r->_leaveSubRecord(); }
};
friend class RecordRAII;
RecordRAII enterSubRecord(const char* name);
template <class T>
void enumerate(const char* name, T& record)
{
if (auto rec = enterSubRecord(name))
record.read(*this);
}
class VectorRAII
{
friend class YAMLDocReader;
YAMLDocReader* m_r = nullptr;
VectorRAII(YAMLDocReader* r) : m_r(r) {}
VectorRAII() = default;
public:
operator bool() const { return m_r != nullptr; }
~VectorRAII() { if (m_r) m_r->_leaveSubVector(); }
};
friend class VectorRAII;
VectorRAII enterSubVector(const char* name, size_t& countOut);
template <class T>
size_t enumerate(const char* name, std::vector<T>& vector,
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)
{
size_t countOut;
if (auto v = enterSubVector(name, countOut))
{
vector.clear();
vector.reserve(countOut);
for (size_t i=0 ; i<countOut ; ++i)
{
vector.emplace_back();
if (auto rec = enterSubRecord(nullptr))
vector.back().read(*this);
}
}
return countOut;
}
template <class T>
size_t enumerate(const char* name, std::vector<T>& vector,
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)
{
size_t countOut;
if (auto v = enterSubVector(name, countOut))
{
vector.clear();
vector.reserve(countOut);
for (size_t i=0 ; i<countOut ; ++i)
vector.push_back(readVal<T>(name));
}
return countOut;
}
template <class T>
size_t enumerate(const char* name, std::vector<T>& vector,
std::function<void(YAMLDocReader&, T&)> readf)
{
size_t countOut;
if (auto v = enterSubVector(name, countOut))
{
vector.clear();
vector.reserve(countOut);
for (size_t i=0 ; i<countOut ; ++i)
{
vector.emplace_back();
if (auto rec = enterSubRecord(nullptr))
readf(*this, vector.back());
}
}
return countOut;
}
bool hasVal(const char* name) const
{
if (m_subStack.size())
{
const YAMLNode* mnode = m_subStack.back();
if (mnode->m_type == YAML_MAPPING_NODE && name)
for (const auto& item : mnode->m_mapChildren)
if (!item.first.compare(name))
return true;
}
return false; return false;
} dna.read(docReader);
return true;
}
template <typename RETURNTYPE> template<class DNASubtype>
RETURNTYPE readVal(const char* name); static inline bool ValidateFromYAMLString(std::string_view str)
bool readBool(const char* name);
atInt8 readByte(const char* name);
atUint8 readUByte(const char* name);
atInt16 readInt16(const char* name);
atUint16 readUint16(const char* name);
atInt32 readInt32(const char* name);
atUint32 readUint32(const char* name);
atInt64 readInt64(const char* name);
atUint64 readUint64(const char* name);
float readFloat(const char* name);
double readDouble(const char* name);
atVec2f readVec2f(const char* name);
atVec3f readVec3f(const char* name);
atVec4f readVec4f(const char* name);
atVec2d readVec2d(const char* name);
atVec3d readVec3d(const char* name);
atVec4d readVec4d(const char* name);
std::unique_ptr<atUint8[]> readUBytes(const char* name);
std::string readString(const char* name);
std::wstring readWString(const char* name);
};
class YAMLDocWriter
{ {
std::unique_ptr<YAMLNode> m_rootNode; YAMLStdStringViewReaderState reader(str);
std::vector<YAMLNode*> m_subStack; YAMLDocReader docReader;
yaml_emitter_t m_emitter; yaml_parser_set_input(docReader.getParser(), (yaml_read_handler_t*)YAMLStdStringReader, &reader);
static bool RecursiveFinish(yaml_emitter_t* doc, const YAMLNode& node); bool retval = docReader.ValidateClassType(DNASubtype::DNAType());
void _leaveSubRecord(); return retval;
void _leaveSubVector(); }
public:
YAMLDocWriter(const char* classType, athena::io::IStreamReader* reader = nullptr);
~YAMLDocWriter();
yaml_emitter_t* getEmitter() { return &m_emitter; } template <class T>
static inline bool ToYAMLStream(const T& dna, athena::io::IStreamWriter& fout)
bool finish(athena::io::IStreamWriter* fout);
inline YAMLNode* getCurNode() const { return m_subStack.empty() ? nullptr : m_subStack.back(); }
class RecordRAII
{
friend class YAMLDocWriter;
YAMLDocWriter* m_w = nullptr;
RecordRAII(YAMLDocWriter* w) : m_w(w) {}
RecordRAII() = default;
public:
operator bool() const { return m_w != nullptr; }
~RecordRAII() { if (m_w) m_w->_leaveSubRecord(); }
};
friend class RecordRAII;
RecordRAII enterSubRecord(const char* name);
template <class T>
void enumerate(const char* name, T& record)
{
if (auto rec = enterSubRecord(name))
record.write(*this);
}
class VectorRAII
{
friend class YAMLDocWriter;
YAMLDocWriter* m_w = nullptr;
VectorRAII(YAMLDocWriter* w) : m_w(w) {}
VectorRAII() = default;
public:
operator bool() const { return m_w != nullptr; }
~VectorRAII() { if (m_w) m_w->_leaveSubVector(); }
};
friend class VectorRAII;
VectorRAII enterSubVector(const char* name);
template <class T>
void enumerate(const char* name, const std::vector<T>& vector,
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 &&
!std::is_same<T, atVec2d>::value &&
!std::is_same<T, atVec3d>::value &&
!std::is_same<T, atVec4d>::value>::type* = 0)
{
if (auto v = enterSubVector(name))
for (const T& item : vector)
if (auto rec = enterSubRecord(nullptr))
item.write(*this);
}
template <class T>
void enumerate(const char* name, const std::vector<T>& vector,
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 ||
std::is_same<T, atVec2d>::value ||
std::is_same<T, atVec3d>::value ||
std::is_same<T, atVec4d>::value>::type* = 0)
{
if (auto v = enterSubVector(name))
for (T item : vector)
writeVal<T>(nullptr, item);
}
template <class T>
void enumerate(const char* name, const std::vector<T>& vector,
std::function<void(YAMLDocWriter&, const T&)> writef)
{
if (auto v = enterSubVector(name))
for (const T& item : vector)
if (auto rec = enterSubRecord(nullptr))
writef(*this, item);
}
template <typename INTYPE>
void writeVal(const char* name, const INTYPE& val);
template <typename INTYPE>
void writeVal(const char* name, const INTYPE& val, size_t byteCount);
void writeBool(const char* name, const bool& val);
void writeByte(const char* name, const atInt8& val);
void writeUByte(const char* name, const atUint8& val);
void writeInt16(const char* name, const atInt16& val);
void writeUint16(const char* name, const atUint16& val);
void writeInt32(const char* name, const atInt32& val);
void writeUint32(const char* name, const atUint32& val);
void writeInt64(const char* name, const atInt64& val);
void writeUint64(const char* name, const atUint64& val);
void writeFloat(const char* name, const float& val);
void writeDouble(const char* name, const double& val);
void writeVec2f(const char* name, const atVec2f& val);
void writeVec3f(const char* name, const atVec3f& val);
void writeVec4f(const char* name, const atVec4f& val);
void writeVec2d(const char* name, const atVec2d& val);
void writeVec3d(const char* name, const atVec3d& val);
void writeVec4d(const char* name, const atVec4d& val);
void writeUBytes(const char* name, const std::unique_ptr<atUint8[]>& val, size_t byteCount);
void writeString(const char* name, std::string_view val);
void writeWString(const char* name, std::wstring_view val);
void writeU16String(const char* name, std::u16string_view val);
void writeU32String(const char* name, std::u32string_view val);
void setStyle(YAMLNodeStyle s);
};
int YAMLAthenaReader(athena::io::IStreamReader* reader,
unsigned char* buffer, size_t size, size_t* size_read);
int YAMLAthenaWriter(athena::io::IStreamWriter* writer,
unsigned char *buffer, size_t size);
/* forward-declaration dance for recursively-derived types */
template <size_t sizeVar, Endian VE>
struct BufferYaml;
template <atInt32 sizeVar, Endian VE>
struct StringYaml;
template <atInt32 sizeVar, Endian VE>
struct WStringYaml;
template <atInt32 sizeVar, Endian VE>
struct WStringAsStringYaml;
template <Endian DNAE>
struct DNAYaml : DNA<DNAE>
{ {
virtual ~DNAYaml() = default; YAMLDocWriter docWriter(dna.DNAType());
virtual void read(IStreamReader& r)=0; yaml_emitter_set_unicode(docWriter.getEmitter(), true);
virtual void write(IStreamWriter& w) const=0; yaml_emitter_set_width(docWriter.getEmitter(), -1);
virtual void read(YAMLDocReader& in)=0;
virtual void write(YAMLDocWriter& out) const=0;
static const char* DNAType() { return nullptr; }
virtual const char* DNATypeV() const { return nullptr; }
template <size_t sizeVar> dna.write(docWriter);
using Buffer = struct athena::io::BufferYaml<sizeVar, DNAE>; return docWriter.finish(&fout);
}
template <atInt32 sizeVar = -1> template <class T>
using String = struct athena::io::StringYaml<sizeVar, DNAE>; static inline bool ToYAMLStream(const T& dna, athena::io::IStreamWriter& fout,
void(T::*fn)(YAMLDocWriter& out)const)
template <atInt32 sizeVar = -1, Endian VE = DNAE>
using WString = struct athena::io::WStringYaml<sizeVar, VE>;
template <atInt32 sizeVar = -1>
using WStringAsString = struct athena::io::WStringAsStringYaml<sizeVar, DNAE>;
std::string toYAMLString() const
{
YAMLDocWriter docWriter(DNATypeV());
std::string res;
yaml_emitter_set_output(docWriter.getEmitter(), (yaml_write_handler_t*)YAMLStdStringWriter, &res);
yaml_emitter_set_unicode(docWriter.getEmitter(), true);
yaml_emitter_set_width(docWriter.getEmitter(), -1);
write(docWriter);
if (!docWriter.finish(nullptr))
return std::string();
return res;
}
bool fromYAMLString(std::string_view str)
{
YAMLStdStringViewReaderState reader(str);
YAMLDocReader docReader;
yaml_parser_set_input(docReader.getParser(), (yaml_read_handler_t*)YAMLStdStringReader, &reader);
if (!docReader.parse(nullptr))
return false;
read(docReader);
return true;
}
template<class DNASubtype>
static bool ValidateFromYAMLString(std::string_view str)
{
YAMLStdStringViewReaderState reader(str);
YAMLDocReader docReader;
yaml_parser_set_input(docReader.getParser(), (yaml_read_handler_t*)YAMLStdStringReader, &reader);
bool retval = docReader.ValidateClassType(DNASubtype::DNAType());
return retval;
}
bool toYAMLStream(athena::io::IStreamWriter& fout) const
{
YAMLDocWriter docWriter(DNATypeV());
yaml_emitter_set_unicode(docWriter.getEmitter(), true);
yaml_emitter_set_width(docWriter.getEmitter(), -1);
write(docWriter);
if (!docWriter.finish(&fout))
return false;
return true;
}
typedef void (DNAYaml::*YAMLWriteMemberFn)(YAMLDocWriter& out) const;
bool toYAMLStream(athena::io::IStreamWriter& fout, YAMLWriteMemberFn fn) const
{
YAMLDocWriter docWriter(DNATypeV());
yaml_emitter_set_unicode(docWriter.getEmitter(), true);
yaml_emitter_set_width(docWriter.getEmitter(), -1);
(this->*fn)(docWriter);
if (!docWriter.finish(&fout))
return false;
return true;
}
bool fromYAMLStream(athena::io::IStreamReader& fin)
{
YAMLDocReader docReader;
if (!docReader.parse(&fin))
return false;
read(docReader);
return true;
}
typedef void (DNAYaml::*YAMLReadMemberFn)(YAMLDocReader& in);
bool fromYAMLStream(athena::io::IStreamReader& fin, YAMLReadMemberFn fn)
{
YAMLDocReader docReader;
if (!docReader.parse(&fin))
return false;
(this->*fn)(docReader);
return true;
}
template <typename NameT>
bool mergeToYAMLFile(const NameT& filename)
{
athena::io::FileReader r(filename);
YAMLDocWriter docWriter(DNATypeV(), r.isOpen() ? &r : nullptr);
r.close();
write(docWriter);
athena::io::FileWriter w(filename);
if (!w.isOpen())
return false;
return docWriter.finish(&w);
}
template<class DNASubtype>
static bool ValidateFromYAMLStream(athena::io::IStreamReader& fin)
{
YAMLDocReader reader;
atUint64 pos = fin.position();
yaml_parser_set_input(reader.getParser(), (yaml_read_handler_t*)YAMLAthenaReader, &fin);
bool retval = reader.ValidateClassType(DNASubtype::DNAType());
fin.seek(pos, athena::Begin);
return retval;
}
};
template <size_t sizeVar, Endian VE>
struct BufferYaml : public DNAYaml<VE>, public std::unique_ptr<atUint8[]>
{ {
typename DNA<VE>::Delete expl; YAMLDocWriter docWriter(dna.DNAType());
void read(IStreamReader& reader)
{
reset(new atUint8[sizeVar]);
reader.readUBytesToBuf(get(), sizeVar);
}
void write(IStreamWriter& writer) const
{
writer.writeUBytes(get(), sizeVar);
}
size_t binarySize(size_t __isz) const
{
return __isz + sizeVar;
}
void read(athena::io::YAMLDocReader& reader)
{*this = reader.readUBytes(nullptr);}
void write(athena::io::YAMLDocWriter& writer) const
{writer.writeUBytes(nullptr, *this, sizeVar);}
};
template <atInt32 sizeVar, Endian VE> yaml_emitter_set_unicode(docWriter.getEmitter(), true);
struct StringYaml : public DNAYaml<VE>, public std::string yaml_emitter_set_width(docWriter.getEmitter(), -1);
(dna->*fn)(docWriter);
return docWriter.finish(&fout);
}
template <class T>
static inline bool FromYAMLStream(T& dna, athena::io::IStreamReader& fin)
{ {
typename DNA<VE>::Delete expl; YAMLDocReader docReader;
void read(IStreamReader& reader) if (!docReader.parse(&fin))
{this->assign(std::move(reader.readString(sizeVar)));} return false;
void write(IStreamWriter& writer) const dna.read(docReader);
{writer.writeString(*this, sizeVar);} return true;
size_t binarySize(size_t __isz) const }
{return __isz + ((sizeVar<0)?(this->size()+1):sizeVar);}
void read(athena::io::YAMLDocReader& reader)
{this->assign(std::move(reader.readString(nullptr)));}
void write(athena::io::YAMLDocWriter& writer) const
{writer.writeString(nullptr, *this);}
StringYaml() = default;
StringYaml(std::string_view __str) : std::string(__str) {}
StringYaml(std::string&& __str) : std::string(std::move(__str)) {}
std::string& operator=(std::string_view __str)
{return this->assign(__str);}
std::string& operator=(std::string&& __str)
{static_cast<std::string&>(*this) = std::move(__str); return *this;}
};
template <atInt32 sizeVar, Endian VE> template <class T>
struct WStringYaml : public DNAYaml<VE>, public std::wstring static inline bool FromYAMLStream(T& dna, athena::io::IStreamReader& fin,
void(T::*fn)(YAMLDocReader& in))
{ {
typename DNA<VE>::Delete expl; YAMLDocReader docReader;
void read(IStreamReader& reader) if (!docReader.parse(&fin))
{ return false;
reader.setEndian(VE); (dna->*fn)(docReader);
this->assign(std::move(reader.readWString(sizeVar))); return true;
} }
void write(IStreamWriter& writer) const
{
writer.setEndian(VE);
writer.writeWString(*this, sizeVar);
}
size_t binarySize(size_t __isz) const
{return __isz + (((sizeVar<0)?(this->size()+1):sizeVar)*2);}
void read(athena::io::YAMLDocReader& reader)
{this->assign(std::move(reader.readWString(nullptr)));}
void write(athena::io::YAMLDocWriter& writer) const
{writer.writeWString(nullptr, *this);}
std::wstring& operator=(std::wstring_view __str)
{return this->assign(__str);}
std::wstring& operator=(std::wstring&& __str)
{this->swap(__str); return *this;}
};
template <atInt32 sizeVar, Endian VE> template <class T, typename NameT>
struct WStringAsStringYaml : public DNAYaml<VE>, public std::string static inline bool MergeToYAMLFile(const T& dna, const NameT& filename)
{ {
typename DNA<VE>::Delete expl; athena::io::FileReader r(filename);
void read(IStreamReader& reader) YAMLDocWriter docWriter(dna.DNAType(), r.isOpen() ? &r : nullptr);
{*this = reader.readWStringAsString(sizeVar);} r.close();
void write(IStreamWriter& writer) const
{writer.writeStringAsWString(*this, sizeVar);}
size_t binarySize(size_t __isz) const
{return __isz + (((sizeVar<0)?(this->size()+1):sizeVar)*2);}
void read(athena::io::YAMLDocReader& reader)
{this->assign(std::move(reader.readString(nullptr)));}
void write(athena::io::YAMLDocWriter& writer) const
{writer.writeString(nullptr, *this);}
std::string& operator=(std::string_view __str)
{return this->assign(__str);}
std::string& operator=(std::string&& __str)
{this->swap(__str); return *this;}
};
/** Macro to automatically declare YAML read/write methods in subclasses */ dna.write(docWriter);
#define DECL_YAML \ athena::io::FileWriter w(filename);
DECL_DNA \ if (!w.isOpen())
void read(athena::io::YAMLDocReader&); \ return false;
void write(athena::io::YAMLDocWriter&) const; \ return docWriter.finish(&w);
static const char* DNAType(); \ }
const char* DNATypeV() const {return DNAType();} \
/** Macro to automatically declare YAML read/write methods with client-code's definition */ template <class DNASubtype>
#define DECL_EXPLICIT_YAML \ static inline bool ValidateFromYAMLStream(athena::io::IStreamReader& fin)
void read(athena::io::YAMLDocReader&); \ {
void write(athena::io::YAMLDocWriter&) const; \ YAMLDocReader reader;
static const char* DNAType(); \ atUint64 pos = fin.position();
const char* DNATypeV() const {return DNAType();} \ yaml_parser_set_input(reader.getParser(), (yaml_read_handler_t*)YAMLAthenaReader, &fin);
bool retval = reader.ValidateClassType(DNASubtype::DNAType());
fin.seek(pos, athena::Begin);
return retval;
}
} }

4
include/athena/Global.hpp
View File

@ -134,8 +134,8 @@ enum SeekOrigin
enum Endian enum Endian
{ {
LittleEndian, Little,
BigEndian Big
}; };
} // Athena } // Athena

6
include/athena/IStream.hpp
View File

@ -15,8 +15,8 @@ public:
inline void setEndian(Endian endian) { m_endian = endian; } inline void setEndian(Endian endian) { m_endian = endian; }
inline Endian endian() const { return m_endian; } inline Endian endian() const { return m_endian; }
inline bool isBigEndian() const { return (m_endian == Endian::BigEndian); } inline bool isBigEndian() const { return (m_endian == Endian::Big); }
inline bool isLittleEndian() const { return (m_endian == Endian::LittleEndian); } inline bool isLittleEndian() const { return (m_endian == Endian::Little); }
virtual void seek(atInt64, SeekOrigin) = 0; virtual void seek(atInt64, SeekOrigin) = 0;
virtual bool atEnd() const = 0; virtual bool atEnd() const = 0;
virtual atUint64 position() const = 0; virtual atUint64 position() const = 0;
@ -26,7 +26,7 @@ protected:
void setError() { m_hasError = true; } void setError() { m_hasError = true; }
bool m_hasError = false; bool m_hasError = false;
#if __BYTE_ORDER == __BIG_ENDIAN #if __BYTE_ORDER == __BIG_ENDIAN
Endian m_endian = BigEndian; Endian m_endian = Big;
#else #else
Endian m_endian = LittleEndian; Endian m_endian = LittleEndian;
#endif #endif

145
include/athena/IStreamReader.hpp
View File

@ -137,7 +137,7 @@ public:
{ {
atInt16 val; atInt16 val;
readUBytesToBuf(&val, 2); readUBytesToBuf(&val, 2);
return m_endian == BigEndian ? utility::BigInt16(val) : utility::LittleInt16(val); return m_endian == Big ? utility::BigInt16(val) : utility::LittleInt16(val);
} }
template <class T> template <class T>
inline atInt16 readVal(typename std::enable_if<std::is_same<T, atInt16>::value>::type* = 0) inline atInt16 readVal(typename std::enable_if<std::is_same<T, atInt16>::value>::type* = 0)
@ -223,7 +223,7 @@ public:
{ {
atInt32 val; atInt32 val;
readUBytesToBuf(&val, 4); readUBytesToBuf(&val, 4);
return m_endian == BigEndian ? utility::BigInt32(val) : utility::LittleInt32(val); return m_endian == Big ? utility::BigInt32(val) : utility::LittleInt32(val);
} }
template <class T> template <class T>
inline atInt32 readVal(typename std::enable_if<std::is_same<T, atInt32>::value>::type* = 0) inline atInt32 readVal(typename std::enable_if<std::is_same<T, atInt32>::value>::type* = 0)
@ -309,7 +309,7 @@ public:
{ {
atInt64 val; atInt64 val;
readUBytesToBuf(&val, 8); readUBytesToBuf(&val, 8);
return m_endian == BigEndian ? utility::BigInt64(val) : utility::LittleInt64(val); return m_endian == Big ? utility::BigInt64(val) : utility::LittleInt64(val);
} }
template <class T> template <class T>
inline atInt64 readVal(typename std::enable_if<std::is_same<T, atInt64>::value>::type* = 0) inline atInt64 readVal(typename std::enable_if<std::is_same<T, atInt64>::value>::type* = 0)
@ -395,7 +395,7 @@ public:
{ {
float val; float val;
readUBytesToBuf(&val, 4); readUBytesToBuf(&val, 4);
return m_endian == BigEndian ? utility::BigFloat(val) : utility::LittleFloat(val); return m_endian == Big ? utility::BigFloat(val) : utility::LittleFloat(val);
} }
template <class T> template <class T>
inline float readVal(typename std::enable_if<std::is_same<T, float>::value>::type* = 0) inline float readVal(typename std::enable_if<std::is_same<T, float>::value>::type* = 0)
@ -440,7 +440,7 @@ public:
{ {
double val; double val;
readUBytesToBuf(&val, 8); readUBytesToBuf(&val, 8);
return m_endian == BigEndian ? utility::BigDouble(val) : utility::LittleDouble(val); return m_endian == Big ? utility::BigDouble(val) : utility::LittleDouble(val);
} }
template <class T> template <class T>
inline double readVal(typename std::enable_if<std::is_same<T, double>::value>::type* = 0) inline double readVal(typename std::enable_if<std::is_same<T, double>::value>::type* = 0)
@ -505,7 +505,7 @@ public:
{ {
atVec2f val; atVec2f val;
readUBytesToBuf(&val, 8); readUBytesToBuf(&val, 8);
if (m_endian == BigEndian) if (m_endian == Big)
{ {
utility::BigFloat(val.vec[0]); utility::BigFloat(val.vec[0]);
utility::BigFloat(val.vec[1]); utility::BigFloat(val.vec[1]);
@ -564,7 +564,7 @@ public:
{ {
atVec3f val; atVec3f val;
readUBytesToBuf(&val, 12); readUBytesToBuf(&val, 12);
if (m_endian == BigEndian) if (m_endian == Big)
{ {
utility::BigFloat(val.vec[0]); utility::BigFloat(val.vec[0]);
utility::BigFloat(val.vec[1]); utility::BigFloat(val.vec[1]);
@ -627,7 +627,7 @@ public:
{ {
atVec4f val; atVec4f val;
readUBytesToBuf(&val, 16); readUBytesToBuf(&val, 16);
if (m_endian == BigEndian) if (m_endian == Big)
{ {
utility::BigFloat(val.vec[0]); utility::BigFloat(val.vec[0]);
utility::BigFloat(val.vec[1]); utility::BigFloat(val.vec[1]);
@ -694,7 +694,7 @@ public:
{ {
atVec2d val; atVec2d val;
readUBytesToBuf(&val, 16); readUBytesToBuf(&val, 16);
if (m_endian == BigEndian) if (m_endian == Big)
{ {
utility::BigDouble(val.vec[0]); utility::BigDouble(val.vec[0]);
utility::BigDouble(val.vec[1]); utility::BigDouble(val.vec[1]);
@ -753,7 +753,7 @@ public:
{ {
atVec3d val; atVec3d val;
readUBytesToBuf(&val, 24); readUBytesToBuf(&val, 24);
if (m_endian == BigEndian) if (m_endian == Big)
{ {
utility::BigDouble(val.vec[0]); utility::BigDouble(val.vec[0]);
utility::BigDouble(val.vec[1]); utility::BigDouble(val.vec[1]);
@ -816,7 +816,7 @@ public:
{ {
atVec4d val; atVec4d val;
readUBytesToBuf(&val, 32); readUBytesToBuf(&val, 32);
if (m_endian == BigEndian) if (m_endian == Big)
{ {
utility::BigDouble(val.vec[0]); utility::BigDouble(val.vec[0]);
utility::BigDouble(val.vec[1]); utility::BigDouble(val.vec[1]);
@ -874,129 +874,6 @@ public:
inline atVec4d readValBig(typename std::enable_if<std::is_same<T, atVec4d>::value>::type* = 0) inline atVec4d readValBig(typename std::enable_if<std::is_same<T, atVec4d>::value>::type* = 0)
{return readVec4dBig();} {return readVec4dBig();}
/** @brief Reads a wide-char string (using endianness from setEndian),
* converts to UTF8 and advances the position in the file
*
* @param fixedLen If non-negative, this is a fixed-length string read
* @return The read string
*/
inline std::string readWStringAsString(atInt32 fixedLen = -1)
{
if (fixedLen == 0)
return std::string();
std::string retval;
atUint16 chr = readUint16();
atInt32 i;
for (i=0 ;; ++i)
{
if (fixedLen >= 0 && i >= fixedLen - 1)
break;
if (!chr)
break;
utf8proc_uint8_t mb[4];
utf8proc_ssize_t c = utf8proc_encode_char(utf8proc_int32_t(chr), mb);
if (c < 0)
{
atWarning("invalid UTF-8 character while encoding");
return retval;
}
retval.append(reinterpret_cast<char*>(mb), c);
chr = readUint16();
}
if (fixedLen >= 0 && i < fixedLen)
seek(fixedLen - i);
return retval;
}
/** @brief Reads a wide-char string (against little-endian),
* converts to UTF8 and advances the position in the file
*
* @param fixedLen If non-negative, this is a fixed-length string read
* @return The read string
*/
inline std::string readWStringAsStringLittle(atInt32 fixedLen = -1)
{
if (fixedLen == 0)
return std::string();
std::string retval;
atUint16 chr = readUint16Little();
atInt32 i;
for (i=0 ;; ++i)
{
if (fixedLen >= 0 && i >= fixedLen - 1)
break;
if (!chr)
break;
utf8proc_uint8_t mb[4];
utf8proc_ssize_t c = utf8proc_encode_char(utf8proc_int32_t(chr), mb);
if (c < 0)
{
atWarning("invalid UTF-8 character while encoding");
return retval;
}
retval.append(reinterpret_cast<char*>(mb), c);
chr = readUint16Little();
}
if (fixedLen >= 0 && i < fixedLen)
seek(fixedLen - i);
return retval;
}
/** @brief Reads a wide-char string (against big-endian),
* converts to UTF8 and advances the position in the file
*
* @param fixedLen If non-negative, this is a fixed-length string read
* @return The read string
*/
inline std::string readWStringAsStringBig(atInt32 fixedLen = -1)
{
if (fixedLen == 0)
return std::string();
std::string retval;
atUint16 chr = readUint16Big();
atInt32 i;
for (i = 0 ;; ++i)
{
if (fixedLen >= 0 && i >= fixedLen - 1)
break;
if (!chr)
break;
utf8proc_uint8_t mb[4];
utf8proc_ssize_t c = utf8proc_encode_char(utf8proc_int32_t(chr), mb);
if (c < 0)
{
atWarning("invalid UTF-8 character while encoding");
return retval;
}
retval.append(reinterpret_cast<char*>(mb), c);
chr = readUint16Big();
}
if (fixedLen >= 0 && i < fixedLen)
seek(fixedLen - i);
return retval;
}
/** @brief Reads a string and advances the position in the file /** @brief Reads a string and advances the position in the file
* *
* @param fixedLen If non-negative, this is a fixed-length string read * @param fixedLen If non-negative, this is a fixed-length string read

22
include/athena/IStreamWriter.hpp
View File

@ -90,7 +90,7 @@ public:
*/ */
inline void writeInt16(atInt16 val) inline void writeInt16(atInt16 val)
{ {
if (m_endian == BigEndian) if (m_endian == Big)
utility::BigInt16(val); utility::BigInt16(val);
else else
utility::LittleInt16(val); utility::LittleInt16(val);
@ -153,7 +153,7 @@ public:
*/ */
inline void writeInt32(atInt32 val) inline void writeInt32(atInt32 val)
{ {
if (m_endian == BigEndian) if (m_endian == Big)
utility::BigInt32(val); utility::BigInt32(val);
else else
utility::LittleInt32(val); utility::LittleInt32(val);
@ -216,7 +216,7 @@ public:
*/ */
inline void writeInt64(atInt64 val) inline void writeInt64(atInt64 val)
{ {
if (m_endian == BigEndian) if (m_endian == Big)
utility::BigInt64(val); utility::BigInt64(val);
else else
utility::LittleInt64(val); utility::LittleInt64(val);
@ -279,7 +279,7 @@ public:
*/ */
inline void writeFloat(float val) inline void writeFloat(float val)
{ {
if (m_endian == BigEndian) if (m_endian == Big)
utility::BigFloat(val); utility::BigFloat(val);
else else
utility::LittleFloat(val); utility::LittleFloat(val);
@ -318,7 +318,7 @@ public:
*/ */
inline void writeDouble(double val) inline void writeDouble(double val)
{ {
if (m_endian == BigEndian) if (m_endian == Big)
utility::BigDouble(val); utility::BigDouble(val);
else else
utility::LittleDouble(val); utility::LittleDouble(val);
@ -368,7 +368,7 @@ public:
inline void writeVec2f(const atVec2f& vec) inline void writeVec2f(const atVec2f& vec)
{ {
atVec2f tmp = vec; atVec2f tmp = vec;
if (m_endian == BigEndian) if (m_endian == Big)
{ {
utility::BigFloat(tmp.vec[0]); utility::BigFloat(tmp.vec[0]);
utility::BigFloat(tmp.vec[1]); utility::BigFloat(tmp.vec[1]);
@ -418,7 +418,7 @@ public:
inline void writeVec3f(const atVec3f& vec) inline void writeVec3f(const atVec3f& vec)
{ {
atVec3f tmp = vec; atVec3f tmp = vec;
if (m_endian == BigEndian) if (m_endian == Big)
{ {
utility::BigFloat(tmp.vec[0]); utility::BigFloat(tmp.vec[0]);
utility::BigFloat(tmp.vec[1]); utility::BigFloat(tmp.vec[1]);
@ -472,7 +472,7 @@ public:
inline void writeVec4f(const atVec4f& vec) inline void writeVec4f(const atVec4f& vec)
{ {
atVec4f tmp = vec; atVec4f tmp = vec;
if (m_endian == BigEndian) if (m_endian == Big)
{ {
utility::BigFloat(tmp.vec[0]); utility::BigFloat(tmp.vec[0]);
utility::BigFloat(tmp.vec[1]); utility::BigFloat(tmp.vec[1]);
@ -530,7 +530,7 @@ public:
inline void writeVec2d(const atVec2d& vec) inline void writeVec2d(const atVec2d& vec)
{ {
atVec2d tmp = vec; atVec2d tmp = vec;
if (m_endian == BigEndian) if (m_endian == Big)
{ {
utility::BigDouble(tmp.vec[0]); utility::BigDouble(tmp.vec[0]);
utility::BigDouble(tmp.vec[1]); utility::BigDouble(tmp.vec[1]);
@ -580,7 +580,7 @@ public:
inline void writeVec3d(const atVec3d& vec) inline void writeVec3d(const atVec3d& vec)
{ {
atVec3d tmp = vec; atVec3d tmp = vec;
if (m_endian == BigEndian) if (m_endian == Big)
{ {
utility::BigDouble(tmp.vec[0]); utility::BigDouble(tmp.vec[0]);
utility::BigDouble(tmp.vec[1]); utility::BigDouble(tmp.vec[1]);
@ -634,7 +634,7 @@ public:
inline void writeVec4d(const atVec4d& vec) inline void writeVec4d(const atVec4d& vec)
{ {
atVec4d tmp = vec; atVec4d tmp = vec;
if (m_endian == BigEndian) if (m_endian == Big)
{ {
utility::BigDouble(tmp.vec[0]); utility::BigDouble(tmp.vec[0]);
utility::BigDouble(tmp.vec[1]); utility::BigDouble(tmp.vec[1]);

15
include/athena/WiiBanner.hpp
View File

@ -35,7 +35,8 @@ public:
* \param m_banner * \param m_banner
* \param icons * \param icons
*/ */
WiiBanner(atUint32 gameId, const std::string& title, const std::string& subtitle, WiiImage* m_banner, std::vector<WiiImage*> icons); WiiBanner(atUint32 gameId, const std::u16string& title, const std::u16string& subtitle,
WiiImage* m_banner, std::vector<WiiImage*> icons);
virtual ~WiiBanner(); virtual ~WiiBanner();
/*! /*!
@ -78,25 +79,25 @@ public:
* \brief setTitle * \brief setTitle
* \param title * \param title
*/ */
void setTitle(const std::string& title); void setTitle(const std::u16string& title);
/*! /*!
* \brief title * \brief title
* \return * \return
*/ */
std::string title() const; const std::u16string& title() const;
/*! /*!
* \brief setSubtitle * \brief setSubtitle
* \param subtitle * \param subtitle
*/ */
void setSubtitle(const std::string& subtitle); void setSubtitle(const std::u16string& subtitle);
/*! /*!
* \brief subtitle * \brief subtitle
* \return * \return
*/ */
std::string subtitle() const; const std::u16string& subtitle() const;
/*! /*!
* \brief addIcon * \brief addIcon
@ -168,8 +169,8 @@ private:
atUint32 m_flags; atUint32 m_flags;
atUint32 m_bannerSize; atUint32 m_bannerSize;
std::vector<WiiImage*> m_icons; std::vector<WiiImage*> m_icons;
std::string m_title; std::u16string m_title;
std::string m_subtitle; std::u16string m_subtitle;
}; };
} // zelda } // zelda

200
include/athena/YAMLCommon.hpp Normal file
View File

@ -0,0 +1,200 @@
//
// Created by Jack Andersen on 2/16/18.
//
#ifndef URDE_YAMLCOMMON_HPP
#define URDE_YAMLCOMMON_HPP
#include <cstring>
#include <yaml.h>
#include <utf8proc.h>
#include <vector>
#include "Global.hpp"
namespace athena::io
{
class IStreamReader;
class IStreamWriter;
enum class YAMLNodeStyle
{
Any,
Flow,
Block
};
struct YAMLNode
{
yaml_node_type_t m_type;
std::string m_scalarString;
std::vector<std::unique_ptr<YAMLNode>> m_seqChildren;
std::vector<std::pair<std::string, std::unique_ptr < YAMLNode>>>
m_mapChildren;
YAMLNodeStyle m_style = YAMLNodeStyle::Any;
YAMLNode(yaml_node_type_t type) : m_type(type) {}
inline const YAMLNode* findMapChild(std::string_view key) const
{
for (const auto& item : m_mapChildren)
if (!item.first.compare(key))
return item.second.get();
return nullptr;
}
inline void assignMapChild(std::string_view key, std::unique_ptr <YAMLNode>&& node)
{
for (auto& item : m_mapChildren)
if (!item.first.compare(key))
{
item.second = std::move(node);
return;
}
m_mapChildren.emplace_back(key, std::move(node));
}
};
template<typename RETURNTYPE>
RETURNTYPE NodeToVal(const YAMLNode* node);
template<>
bool NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(bool val);
template<>
atInt8 NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(atInt8 val);
template<>
atUint8 NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(atUint8 val);
template<>
atInt16 NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(atInt16 val);
template<>
atUint16 NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(atUint16 val);
template<>
atInt32 NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(atInt32 val);
template<>
atUint32 NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(atUint32 val);
template<>
atInt64 NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(atInt64 val);
template<>
atUint64 NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(atUint64 val);
template<>
float NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(float val);
template<>
double NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(double val);
template<typename RETURNTYPE>
RETURNTYPE NodeToVec(const YAMLNode* node);
template<>
atVec2f NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(const atVec2f& val);
template<>
atVec3f NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(const atVec3f& val);
template<>
atVec4f NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(const atVec4f& val);
template<>
atVec2d NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(const atVec2d& val);
template<>
atVec3d NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(const atVec3d& val);
template<>
atVec4d NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(const atVec4d& val);
template<>
std::unique_ptr<atUint8[]> NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(const std::unique_ptr<atUint8[]>& val, size_t byteCount);
template<>
std::string NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(std::string_view val);
template<>
std::wstring NodeToVal(const YAMLNode* node);
std::unique_ptr <YAMLNode> ValToNode(std::wstring_view val);
std::unique_ptr <YAMLNode> ValToNode(std::u16string_view val);
std::unique_ptr <YAMLNode> ValToNode(std::u32string_view val);
std::string base64_encode(const atUint8* bytes_to_encode, size_t in_len);
std::unique_ptr<atUint8[]> base64_decode(std::string_view encoded_string);
void HandleYAMLParserError(yaml_parser_t* parser);
void HandleYAMLEmitterError(yaml_emitter_t* emitter);
struct YAMLStdStringViewReaderState
{
std::string_view::const_iterator begin;
std::string_view::const_iterator end;
YAMLStdStringViewReaderState(std::string_view str)
{
begin = str.begin();
end = str.end();
}
};
int YAMLStdStringReader(YAMLStdStringViewReaderState* str,
unsigned char* buffer, size_t size, size_t* size_read);
int YAMLStdStringWriter(std::string* str, unsigned char* buffer, size_t size);
int YAMLAthenaReader(athena::io::IStreamReader* reader,
unsigned char* buffer, size_t size, size_t* size_read);
int YAMLAthenaWriter(athena::io::IStreamWriter* writer,
unsigned char* buffer, size_t size);
}
#endif //URDE_YAMLCOMMON_HPP

169
include/athena/YAMLDocReader.hpp Normal file
View File

@ -0,0 +1,169 @@
#ifndef YAMLDOCREADER
#define YAMLDOCREADER
#include "YAMLCommon.hpp"
namespace athena::io
{
class YAMLDocReader
{
std::unique_ptr<YAMLNode> m_rootNode;
std::vector<YAMLNode*> m_subStack;
std::vector<int> m_seqTrackerStack;
yaml_parser_t m_parser;
std::unique_ptr<YAMLNode> ParseEvents(athena::io::IStreamReader* reader);
void _leaveSubRecord();
void _leaveSubVector();
public:
YAMLDocReader();
~YAMLDocReader();
void reset();
inline yaml_parser_t* getParser() { return &m_parser; }
bool parse(athena::io::IStreamReader* reader);
bool ClassTypeOperation(std::function<bool(const char* dnaType)> func);
bool ValidateClassType(const char* expectedType);
inline const YAMLNode* getRootNode() const { return m_rootNode.get(); }
inline const YAMLNode* getCurNode() const { return m_subStack.empty() ? nullptr : m_subStack.back(); }
std::unique_ptr<YAMLNode> releaseRootNode() { return std::move(m_rootNode); }
class RecordRAII
{
friend class YAMLDocReader;
YAMLDocReader* m_r = nullptr;
RecordRAII(YAMLDocReader* r) : m_r(r) {}
RecordRAII() = default;
public:
operator bool() const { return m_r != nullptr; }
~RecordRAII() { if (m_r) m_r->_leaveSubRecord(); }
};
friend class RecordRAII;
RecordRAII enterSubRecord(const char* name);
template <class T>
void enumerate(const char* name, T& record)
{
if (auto rec = enterSubRecord(name))
record.read(*this);
}
class VectorRAII
{
friend class YAMLDocReader;
YAMLDocReader* m_r = nullptr;
VectorRAII(YAMLDocReader* r) : m_r(r) {}
VectorRAII() = default;
public:
operator bool() const { return m_r != nullptr; }
~VectorRAII() { if (m_r) m_r->_leaveSubVector(); }
};
friend class VectorRAII;
VectorRAII enterSubVector(const char* name, size_t& countOut);
template <class T>
size_t enumerate(const char* name, std::vector<T>& vector,
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)
{
size_t countOut;
if (auto v = enterSubVector(name, countOut))
{
vector.clear();
vector.reserve(countOut);
for (size_t i=0 ; i<countOut ; ++i)
{
vector.emplace_back();
if (auto rec = enterSubRecord(nullptr))
vector.back().read(*this);
}
}
return countOut;
}
template <class T>
size_t enumerate(const char* name, std::vector<T>& vector,
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)
{
size_t countOut;
if (auto v = enterSubVector(name, countOut))
{
vector.clear();
vector.reserve(countOut);
for (size_t i=0 ; i<countOut ; ++i)
vector.push_back(readVal<T>(name));
}
return countOut;
}
template <class T>
size_t enumerate(const char* name, std::vector<T>& vector,
std::function<void(YAMLDocReader&, T&)> readf)
{
size_t countOut;
if (auto v = enterSubVector(name, countOut))
{
vector.clear();
vector.reserve(countOut);
for (size_t i=0 ; i<countOut ; ++i)
{
vector.emplace_back();
if (auto rec = enterSubRecord(nullptr))
readf(*this, vector.back());
}
}
return countOut;
}
bool hasVal(const char* name) const
{
if (m_subStack.size())
{
const YAMLNode* mnode = m_subStack.back();
if (mnode->m_type == YAML_MAPPING_NODE && name)
for (const auto& item : mnode->m_mapChildren)
if (!item.first.compare(name))
return true;
}
return false;
}
template <typename RETURNTYPE>
RETURNTYPE readVal(const char* name);
bool readBool(const char* name);
atInt8 readByte(const char* name);
atUint8 readUByte(const char* name);
atInt16 readInt16(const char* name);
atUint16 readUint16(const char* name);
atInt32 readInt32(const char* name);
atUint32 readUint32(const char* name);
atInt64 readInt64(const char* name);
atUint64 readUint64(const char* name);
float readFloat(const char* name);
double readDouble(const char* name);
atVec2f readVec2f(const char* name);
atVec3f readVec3f(const char* name);
atVec4f readVec4f(const char* name);
atVec2d readVec2d(const char* name);
atVec3d readVec3d(const char* name);
atVec4d readVec4d(const char* name);
std::unique_ptr<atUint8[]> readUBytes(const char* name);
std::string readString(const char* name);
std::wstring readWString(const char* name);
};
}
#endif // YAMLDOCREADER

135
include/athena/YAMLDocWriter.hpp Normal file
View File

@ -0,0 +1,135 @@
#ifndef YAMLDOCWRITER
#define YAMLDOCWRITER
#include "YAMLCommon.hpp"
namespace athena::io
{
class YAMLDocWriter
{
std::unique_ptr<YAMLNode> m_rootNode;
std::vector<YAMLNode*> m_subStack;
yaml_emitter_t m_emitter;
static bool RecursiveFinish(yaml_emitter_t* doc, const YAMLNode& node);
void _leaveSubRecord();
void _leaveSubVector();
public:
YAMLDocWriter(const char* classType, athena::io::IStreamReader* reader = nullptr);
~YAMLDocWriter();
yaml_emitter_t* getEmitter() { return &m_emitter; }
bool finish(athena::io::IStreamWriter* fout);
inline YAMLNode* getCurNode() const { return m_subStack.empty() ? nullptr : m_subStack.back(); }
class RecordRAII
{
friend class YAMLDocWriter;
YAMLDocWriter* m_w = nullptr;
RecordRAII(YAMLDocWriter* w) : m_w(w) {}
RecordRAII() = default;
public:
operator bool() const { return m_w != nullptr; }
~RecordRAII() { if (m_w) m_w->_leaveSubRecord(); }
};
friend class RecordRAII;
RecordRAII enterSubRecord(const char* name);
template <class T>
void enumerate(const char* name, T& record)
{
if (auto rec = enterSubRecord(name))
record.write(*this);
}
class VectorRAII
{
friend class YAMLDocWriter;
YAMLDocWriter* m_w = nullptr;
VectorRAII(YAMLDocWriter* w) : m_w(w) {}
VectorRAII() = default;
public:
operator bool() const { return m_w != nullptr; }
~VectorRAII() { if (m_w) m_w->_leaveSubVector(); }
};
friend class VectorRAII;
VectorRAII enterSubVector(const char* name);
template <class T>
void enumerate(const char* name, const std::vector<T>& vector,
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 &&
!std::is_same<T, atVec2d>::value &&
!std::is_same<T, atVec3d>::value &&
!std::is_same<T, atVec4d>::value>::type* = 0)
{
if (auto v = enterSubVector(name))
for (const T& item : vector)
if (auto rec = enterSubRecord(nullptr))
item.write(*this);
}
template <class T>
void enumerate(const char* name, const std::vector<T>& vector,
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 ||
std::is_same<T, atVec2d>::value ||
std::is_same<T, atVec3d>::value ||
std::is_same<T, atVec4d>::value>::type* = 0)
{
if (auto v = enterSubVector(name))
for (T item : vector)
writeVal<T>(nullptr, item);
}
template <class T>
void enumerate(const char* name, const std::vector<T>& vector,
std::function<void(YAMLDocWriter&, const T&)> writef)
{
if (auto v = enterSubVector(name))
for (const T& item : vector)
if (auto rec = enterSubRecord(nullptr))
writef(*this, item);
}
template <typename INTYPE>
void writeVal(const char* name, const INTYPE& val);
template <typename INTYPE>
void writeVal(const char* name, const INTYPE& val, size_t byteCount);
void writeBool(const char* name, const bool& val);
void writeByte(const char* name, const atInt8& val);
void writeUByte(const char* name, const atUint8& val);
void writeInt16(const char* name, const atInt16& val);
void writeUint16(const char* name, const atUint16& val);
void writeInt32(const char* name, const atInt32& val);
void writeUint32(const char* name, const atUint32& val);
void writeInt64(const char* name, const atInt64& val);
void writeUint64(const char* name, const atUint64& val);
void writeFloat(const char* name, const float& val);
void writeDouble(const char* name, const double& val);
void writeVec2f(const char* name, const atVec2f& val);
void writeVec3f(const char* name, const atVec3f& val);
void writeVec4f(const char* name, const atVec4f& val);
void writeVec2d(const char* name, const atVec2d& val);
void writeVec3d(const char* name, const atVec3d& val);
void writeVec4d(const char* name, const atVec4d& val);
void writeUBytes(const char* name, const std::unique_ptr<atUint8[]>& val, size_t byteCount);
void writeString(const char* name, std::string_view val);
void writeWString(const char* name, std::wstring_view val);
void writeU16String(const char* name, std::u16string_view val);
void writeU32String(const char* name, std::u32string_view val);
void setStyle(YAMLNodeStyle s);
};
}
#endif // YAMLDOCWRITER

2
src/athena/Checksums.cpp
View File

@ -3,7 +3,7 @@
#include <iostream> #include <iostream>
#include <iomanip> #include <iomanip>
namespace athena::Checksums namespace athena::checksums
{ {
atUint32 crc32(const atUint8* data, atUint64 length, atUint32 mask, atUint32 seed) atUint32 crc32(const atUint8* data, atUint64 length, atUint32 mask, atUint32 seed)

3
src/athena/DNAYaml.cpp
View File

@ -341,7 +341,8 @@ std::unique_ptr<atUint8[]> NodeToVal(const YAMLNode* node)
std::unique_ptr<YAMLNode> ValToNode(const std::unique_ptr<atUint8[]>& val, size_t byteCount) std::unique_ptr<YAMLNode> ValToNode(const std::unique_ptr<atUint8[]>& val, size_t byteCount)
{ {
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE); YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
ret->m_scalarString = base64_encode(val.get(), byteCount); if (val)
ret->m_scalarString = base64_encode(val.get(), byteCount);
return std::unique_ptr<YAMLNode>(ret); return std::unique_ptr<YAMLNode>(ret);
} }

4
src/athena/Global.cpp
View File

@ -28,11 +28,11 @@ std::ostream& operator<<(std::ostream& os, const athena::Endian& endian)
{ {
switch (endian) switch (endian)
{ {
case athena::Endian::LittleEndian: case athena::Endian::Little:
os << "LittleEndian"; os << "LittleEndian";
break; break;
case athena::Endian::BigEndian: case athena::Endian::Big:
os << "BigEndian"; os << "BigEndian";
break; break;
} }

2
src/athena/MCSlot.cpp
View File

@ -4,7 +4,7 @@ namespace athena
{ {
MCSlot::MCSlot(std::unique_ptr<atUint8[]>&& data, atUint32 length) MCSlot::MCSlot(std::unique_ptr<atUint8[]>&& data, atUint32 length)
: ZQuestFile(ZQuestFile::MC, Endian::LittleEndian, std::move(data), length) : ZQuestFile(ZQuestFile::MC, Endian::Little, std::move(data), length)
{ {
} }

4
src/athena/SkywardSwordFileReader.cpp
View File

@ -9,13 +9,13 @@ namespace athena::io
SkywardSwordFileReader::SkywardSwordFileReader(atUint8* data, atUint64 length) SkywardSwordFileReader::SkywardSwordFileReader(atUint8* data, atUint64 length)
: MemoryCopyReader(data, length) : MemoryCopyReader(data, length)
{ {
setEndian(Endian::BigEndian); setEndian(Endian::Big);
} }
SkywardSwordFileReader::SkywardSwordFileReader(const std::string& filename) SkywardSwordFileReader::SkywardSwordFileReader(const std::string& filename)
: MemoryCopyReader(filename) : MemoryCopyReader(filename)
{ {
setEndian(Endian::BigEndian); setEndian(Endian::Big);
} }
SkywardSwordFile* SkywardSwordFileReader::read() SkywardSwordFile* SkywardSwordFileReader::read()

4
src/athena/SkywardSwordFileWriter.cpp
View File

@ -8,13 +8,13 @@ namespace athena::io
SkywardSwordFileWriter::SkywardSwordFileWriter(atUint8* data, atUint64 len) SkywardSwordFileWriter::SkywardSwordFileWriter(atUint8* data, atUint64 len)
: MemoryCopyWriter(data, len) : MemoryCopyWriter(data, len)
{ {
setEndian(Endian::BigEndian); setEndian(Endian::Big);
} }
SkywardSwordFileWriter::SkywardSwordFileWriter(const std::string& filename) SkywardSwordFileWriter::SkywardSwordFileWriter(const std::string& filename)
: MemoryCopyWriter(filename) : MemoryCopyWriter(filename)
{ {
setEndian(Endian::BigEndian); setEndian(Endian::Big);
} }
void SkywardSwordFileWriter::write(SkywardSwordFile* file) void SkywardSwordFileWriter::write(SkywardSwordFile* file)

6
src/athena/SkywardSwordQuest.cpp
View File

@ -38,7 +38,7 @@ union AmmoValues
}; };
SkywardSwordQuest::SkywardSwordQuest(std::unique_ptr<atUint8[]>&& data, atUint32 len) SkywardSwordQuest::SkywardSwordQuest(std::unique_ptr<atUint8[]>&& data, atUint32 len)
: ZQuestFile(ZQuestFile::SS, Endian::BigEndian, std::move(data), len) : ZQuestFile(ZQuestFile::SS, Endian::Big, std::move(data), len)
{ {
} }
@ -240,11 +240,11 @@ atUint32 SkywardSwordQuest::skipChecksum()
void SkywardSwordQuest::fixChecksums() void SkywardSwordQuest::fixChecksums()
{ {
atUint32 checksum = Checksums::crc32(m_data.get(), priv::CHECKSUM_OFFSET); atUint32 checksum = checksums::crc32(m_data.get(), priv::CHECKSUM_OFFSET);
utility::BigUint32(checksum); utility::BigUint32(checksum);
*(atUint32*)(m_data.get() + priv::CHECKSUM_OFFSET) = checksum; *(atUint32*)(m_data.get() + priv::CHECKSUM_OFFSET) = checksum;
checksum = Checksums::crc32(m_skipData.get(), priv::SKIP_CHECKSUM_OFFSET); checksum = checksums::crc32(m_skipData.get(), priv::SKIP_CHECKSUM_OFFSET);
utility::BigUint32(checksum); utility::BigUint32(checksum);
*(atUint32*)(m_skipData.get() + priv::SKIP_CHECKSUM_OFFSET) = checksum; *(atUint32*)(m_skipData.get() + priv::SKIP_CHECKSUM_OFFSET) = checksum;
} }

16
src/athena/WiiBanner.cpp
View File

@ -11,14 +11,12 @@ WiiBanner::WiiBanner() :
m_gameId(0), m_gameId(0),
m_banner(NULL), m_banner(NULL),
m_flags(0), m_flags(0),
m_bannerSize(0), m_bannerSize(0)
m_title(""),
m_subtitle("")
{ {
} }
WiiBanner::WiiBanner(atUint32 gameId, const std::string& title, WiiBanner::WiiBanner(atUint32 gameId, const std::u16string& title,
const std::string& subtitle, WiiImage* banner, std::vector<WiiImage*> icons) : const std::u16string& subtitle, WiiImage* banner, std::vector<WiiImage*> icons) :
m_gameId(gameId), m_gameId(gameId),
m_banner(banner), m_banner(banner),
m_flags(0), m_flags(0),
@ -44,22 +42,22 @@ atUint64 WiiBanner::gameID() const
{ {
return m_gameId; return m_gameId;
} }
void WiiBanner::setTitle(const std::string& title) void WiiBanner::setTitle(const std::u16string& title)
{ {
m_title = title; m_title = title;
} }
std::string WiiBanner::title() const const std::u16string& WiiBanner::title() const
{ {
return m_title; return m_title;
} }
void WiiBanner::setSubtitle(const std::string& subtitle) void WiiBanner::setSubtitle(const std::u16string& subtitle)
{ {
m_subtitle = subtitle; m_subtitle = subtitle;
} }
std::string WiiBanner::subtitle() const const std::u16string& WiiBanner::subtitle() const
{ {
return m_subtitle; return m_subtitle;
} }

12
src/athena/WiiSaveReader.cpp
View File

@ -22,13 +22,13 @@ namespace io
WiiSaveReader::WiiSaveReader(const atUint8* data, atUint64 length) WiiSaveReader::WiiSaveReader(const atUint8* data, atUint64 length)
: MemoryCopyReader(data, length) : MemoryCopyReader(data, length)
{ {
setEndian(Endian::BigEndian); setEndian(Endian::Big);
} }
WiiSaveReader::WiiSaveReader(const std::string& filename) WiiSaveReader::WiiSaveReader(const std::string& filename)
: MemoryCopyReader(filename) : MemoryCopyReader(filename)
{ {
setEndian(Endian::BigEndian); setEndian(Endian::Big);
} }
std::unique_ptr<WiiSave> WiiSaveReader::readSave() std::unique_ptr<WiiSave> WiiSaveReader::readSave()
@ -164,8 +164,8 @@ WiiBanner* WiiSaveReader::readBanner()
int magic; int magic;
int flags; int flags;
short animSpeed; short animSpeed;
std::string gameTitle; std::u16string gameTitle;
std::string subTitle; std::u16string subTitle;
magic = readUint32(); magic = readUint32();
@ -183,12 +183,12 @@ WiiBanner* WiiSaveReader::readBanner()
animSpeed = readUint16(); animSpeed = readUint16();
seek(22); seek(22);
gameTitle = readWStringAsString(); gameTitle = readU16StringBig();
if (position() != 0x0080) if (position() != 0x0080)
seek(0x0080, SeekOrigin::Begin); seek(0x0080, SeekOrigin::Begin);
subTitle = readWStringAsString(); subTitle = readU16StringBig();
if (position() != 0x00C0) if (position() != 0x00C0)
seek(0x00C0, SeekOrigin::Begin); seek(0x00C0, SeekOrigin::Begin);

4
src/athena/WiiSaveWriter.cpp
View File

@ -30,7 +30,7 @@ namespace io
WiiSaveWriter::WiiSaveWriter(const std::string& filename) WiiSaveWriter::WiiSaveWriter(const std::string& filename)
: MemoryCopyWriter(filename) : MemoryCopyWriter(filename)
{ {
setEndian(Endian::BigEndian); setEndian(Endian::Big);
} }
@ -83,7 +83,7 @@ bool WiiSaveWriter::writeSave(WiiSave* save, atUint8* macAddress, atUint32 ngId,
void WiiSaveWriter::writeBanner(WiiBanner* banner) void WiiSaveWriter::writeBanner(WiiBanner* banner)
{ {
setEndian(Endian::BigEndian); setEndian(Endian::Big);
writeInt64(banner->gameID()); writeInt64(banner->gameID());
writeInt32((0x60a0 + 0x1200) * (atUint32)banner->icons().size()); writeInt32((0x60a0 + 0x1200) * (atUint32)banner->icons().size());
writeByte((atInt8)banner->permissions()); writeByte((atInt8)banner->permissions());

2
src/athena/ZQuestFile.cpp
View File

@ -39,7 +39,7 @@ const atUint32 ZQuestFile::Magic = 'Z' | ('Q' << 8) | ('S' << 16) | (('0' + ZQ
ZQuestFile::ZQuestFile() ZQuestFile::ZQuestFile()
: m_game(NoGame), : m_game(NoGame),
m_endian(Endian::LittleEndian), m_endian(Endian::Little),
m_length(0) m_length(0)
{ {
initGameStrings(); initGameStrings();

4
src/athena/ZQuestFileReader.cpp
View File

@ -75,7 +75,7 @@ ZQuestFile* ZQuestFileReader::read()
if (version >= ZQUEST_VERSION_CHECK(2, 0, 0)) if (version >= ZQUEST_VERSION_CHECK(2, 0, 0))
{ {
if (checksum != athena::Checksums::crc32(data.get(), compressedLen)) if (checksum != athena::checksums::crc32(data.get(), compressedLen))
{ {
atError("Checksum mismatch, data corrupt"); atError("Checksum mismatch, data corrupt");
return nullptr; return nullptr;
@ -102,7 +102,7 @@ ZQuestFile* ZQuestFileReader::read()
data.reset(dst); data.reset(dst);
} }
return new ZQuestFile(game, BOM == 0xFEFF ? Endian::BigEndian : Endian::LittleEndian, std::move(data), uncompressedLen, gameString); return new ZQuestFile(game, BOM == 0xFEFF ? Endian::Big : Endian::Little, std::move(data), uncompressedLen, gameString);
} }
} // zelda } // zelda

4
src/athena/ZQuestFileWriter.cpp
View File

@ -59,8 +59,8 @@ void ZQuestFileWriter::write(ZQuestFile* quest, bool compress)
writeUint32(quest->length()); writeUint32(quest->length());
writeBytes((atInt8*)quest->gameString().substr(0, 0x0A).c_str(), 0x0A); writeBytes((atInt8*)quest->gameString().substr(0, 0x0A).c_str(), 0x0A);
writeUint16(quest->endian() == Endian::BigEndian ? 0xFFFE : 0xFEFF); writeUint16(quest->endian() == Endian::Big ? 0xFFFE : 0xFEFF);
writeUint32(athena::Checksums::crc32(questData, compLen)); writeUint32(athena::checksums::crc32(questData, compLen));
writeUBytes(questData, compLen); writeUBytes(questData, compLen);
save(); save();