mirror of https://github.com/libAthena/athena.git
Make DNAYaml less header-heavy
This commit is contained in:
Jack Andersen
parent
cecbcffd96
commit
9ccf9f596b
File diff suppressed because it is too large
Load Diff
|
|
@ -5,6 +5,461 @@ namespace athena
|
|||
namespace io
|
||||
{
|
||||
|
||||
template <>
|
||||
bool NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
char firstCh = tolower(node->m_scalarString[0]);
|
||||
if (firstCh == 't')
|
||||
return true;
|
||||
else if (firstCh == 'f')
|
||||
return false;
|
||||
else if (isdigit(firstCh) && firstCh != 0)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(bool val)
|
||||
{
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString = val?"True":"False";
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
atInt8 NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return strtol(node->m_scalarString.c_str(), NULL, 0);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(atInt8 val)
|
||||
{
|
||||
char str[32];
|
||||
snprintf(str, 32, "%d", int(val));
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString = str;
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
atUint8 NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return strtoul(node->m_scalarString.c_str(), NULL, 0);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(atUint8 val)
|
||||
{
|
||||
char str[32];
|
||||
snprintf(str, 32, "0x%02X", val);
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString = str;
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
atInt16 NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return strtol(node->m_scalarString.c_str(), NULL, 0);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(atInt16 val)
|
||||
{
|
||||
char str[32];
|
||||
snprintf(str, 32, "%d", int(val));
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString = str;
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
atUint16 NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return strtoul(node->m_scalarString.c_str(), NULL, 0);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(atUint16 val)
|
||||
{
|
||||
char str[32];
|
||||
snprintf(str, 32, "0x%04X", val);
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString = str;
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
atInt32 NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return strtol(node->m_scalarString.c_str(), NULL, 0);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(atInt32 val)
|
||||
{
|
||||
char str[32];
|
||||
snprintf(str, 32, "%d", int(val));
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString = str;
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
atUint32 NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return strtoul(node->m_scalarString.c_str(), NULL, 0);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(atUint32 val)
|
||||
{
|
||||
char str[32];
|
||||
snprintf(str, 32, "0x%08X", val);
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString = str;
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
atInt64 NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
#if _WIN32
|
||||
return _strtoi64(node->m_scalarString.c_str(), NULL, 0);
|
||||
#else
|
||||
return strtoq(node->m_scalarString.c_str(), NULL, 0);
|
||||
#endif
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(atInt64 val)
|
||||
{
|
||||
char str[32];
|
||||
snprintf(str, 32, "%" PRId64, val);
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString = str;
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
atUint64 NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
#if _WIN32
|
||||
return _strtoui64(node->m_scalarString.c_str(), NULL, 0);
|
||||
#else
|
||||
return strtouq(node->m_scalarString.c_str(), NULL, 0);
|
||||
#endif
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(atUint64 val)
|
||||
{
|
||||
char str[32];
|
||||
snprintf(str, 32, "0x%016" PRIX64, val);
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString = str;
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
float NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return strtof(node->m_scalarString.c_str(), NULL);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(float val)
|
||||
{
|
||||
char str[64];
|
||||
snprintf(str, 64, "%f", val);
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString = str;
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
double NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return strtod(node->m_scalarString.c_str(), NULL);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(double val)
|
||||
{
|
||||
char str[64];
|
||||
snprintf(str, 64, "%f", val);
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString = str;
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <typename RETURNTYPE>
|
||||
RETURNTYPE NodeToVec(const YAMLNode* node)
|
||||
{
|
||||
RETURNTYPE retval = {};
|
||||
auto it = node->m_seqChildren.begin();
|
||||
for (size_t i=0;
|
||||
i<4 && it != node->m_seqChildren.end();
|
||||
++i, ++it)
|
||||
{
|
||||
YAMLNode* snode = it->get();
|
||||
if (snode->m_type == YAML_SCALAR_NODE)
|
||||
{
|
||||
if (std::is_same<RETURNTYPE, atVec2d>::value ||
|
||||
std::is_same<RETURNTYPE, atVec3d>::value ||
|
||||
std::is_same<RETURNTYPE, atVec4d>::value)
|
||||
retval.vec[i] = NodeToVal<double>(snode);
|
||||
else
|
||||
retval.vec[i] = NodeToVal<float>(snode);
|
||||
}
|
||||
else
|
||||
retval.vec[i] = 0.0;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
template <>
|
||||
atVec2f NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return NodeToVec<atVec2f>(node);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const atVec2f& val)
|
||||
{
|
||||
YAMLNode* ret = new YAMLNode(YAML_SEQUENCE_NODE);
|
||||
ret->m_seqChildren.reserve(2);
|
||||
for (size_t i=0 ; i<2 ; ++i)
|
||||
{
|
||||
char str[64];
|
||||
snprintf(str, 64, "%f", val.vec[i]);
|
||||
YAMLNode* comp = new YAMLNode(YAML_SCALAR_NODE);
|
||||
comp->m_scalarString = str;
|
||||
ret->m_seqChildren.emplace_back(comp);
|
||||
}
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
atVec3f NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return NodeToVec<atVec3f>(node);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const atVec3f& val)
|
||||
{
|
||||
YAMLNode* ret = new YAMLNode(YAML_SEQUENCE_NODE);
|
||||
ret->m_seqChildren.reserve(3);
|
||||
for (size_t i=0 ; i<3 ; ++i)
|
||||
{
|
||||
char str[64];
|
||||
snprintf(str, 64, "%f", val.vec[i]);
|
||||
YAMLNode* comp = new YAMLNode(YAML_SCALAR_NODE);
|
||||
comp->m_scalarString = str;
|
||||
ret->m_seqChildren.emplace_back(comp);
|
||||
}
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
atVec4f NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return NodeToVec<atVec4f>(node);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const atVec4f& val)
|
||||
{
|
||||
YAMLNode* ret = new YAMLNode(YAML_SEQUENCE_NODE);
|
||||
ret->m_seqChildren.reserve(4);
|
||||
for (size_t i=0 ; i<4 ; ++i)
|
||||
{
|
||||
char str[64];
|
||||
snprintf(str, 64, "%f", val.vec[i]);
|
||||
YAMLNode* comp = new YAMLNode(YAML_SCALAR_NODE);
|
||||
comp->m_scalarString = str;
|
||||
ret->m_seqChildren.emplace_back(comp);
|
||||
}
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
atVec2d NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return NodeToVec<atVec2d>(node);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const atVec2d& val)
|
||||
{
|
||||
YAMLNode* ret = new YAMLNode(YAML_SEQUENCE_NODE);
|
||||
ret->m_seqChildren.reserve(2);
|
||||
for (size_t i=0 ; i<2 ; ++i)
|
||||
{
|
||||
char str[64];
|
||||
snprintf(str, 64, "%f", val.vec[i]);
|
||||
YAMLNode* comp = new YAMLNode(YAML_SCALAR_NODE);
|
||||
comp->m_scalarString = str;
|
||||
ret->m_seqChildren.emplace_back(comp);
|
||||
}
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
atVec3d NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return NodeToVec<atVec3d>(node);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const atVec3d& val)
|
||||
{
|
||||
YAMLNode* ret = new YAMLNode(YAML_SEQUENCE_NODE);
|
||||
ret->m_seqChildren.reserve(3);
|
||||
for (size_t i=0 ; i<3 ; ++i)
|
||||
{
|
||||
char str[64];
|
||||
snprintf(str, 64, "%f", val.vec[i]);
|
||||
YAMLNode* comp = new YAMLNode(YAML_SCALAR_NODE);
|
||||
comp->m_scalarString = str;
|
||||
ret->m_seqChildren.emplace_back(comp);
|
||||
}
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
atVec4d NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return NodeToVec<atVec4d>(node);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const atVec4d& val)
|
||||
{
|
||||
YAMLNode* ret = new YAMLNode(YAML_SEQUENCE_NODE);
|
||||
ret->m_seqChildren.reserve(4);
|
||||
for (size_t i=0 ; i<4 ; ++i)
|
||||
{
|
||||
char str[64];
|
||||
snprintf(str, 64, "%f", val.vec[i]);
|
||||
YAMLNode* comp = new YAMLNode(YAML_SCALAR_NODE);
|
||||
comp->m_scalarString = str;
|
||||
ret->m_seqChildren.emplace_back(comp);
|
||||
}
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
std::unique_ptr<atUint8[]> NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return base64_decode(node->m_scalarString);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const std::unique_ptr<atUint8[]>& val, size_t byteCount)
|
||||
{
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString = base64_encode(val.get(), byteCount);
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
std::string NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
return node->m_scalarString;
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const std::string& val)
|
||||
{
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString = val;
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const char* val)
|
||||
{
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString = val;
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
template <>
|
||||
std::wstring NodeToVal(const YAMLNode* node)
|
||||
{
|
||||
std::wstring retval;
|
||||
retval.reserve(node->m_scalarString.length());
|
||||
const utf8proc_uint8_t* buf = reinterpret_cast<const utf8proc_uint8_t*>(node->m_scalarString.c_str());
|
||||
while (*buf)
|
||||
{
|
||||
utf8proc_int32_t wc;
|
||||
utf8proc_ssize_t len = utf8proc_iterate(buf, -1, &wc);
|
||||
if (len < 0)
|
||||
{
|
||||
atWarning("invalid UTF-8 character while decoding");
|
||||
return retval;
|
||||
}
|
||||
buf += len;
|
||||
retval += wchar_t(wc);
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const std::wstring& val)
|
||||
{
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString.reserve(val.length());
|
||||
for (wchar_t ch : val)
|
||||
{
|
||||
utf8proc_uint8_t mb[4];
|
||||
utf8proc_ssize_t c = utf8proc_encode_char(utf8proc_int32_t(ch), mb);
|
||||
if (c < 0)
|
||||
{
|
||||
atWarning("invalid UTF-8 character while encoding");
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
ret->m_scalarString.append(reinterpret_cast<char*>(mb), c);
|
||||
}
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const wchar_t* val)
|
||||
{
|
||||
std::wstring wstr(val);
|
||||
return ValToNode(wstr);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const std::u16string& val)
|
||||
{
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString.reserve(val.length());
|
||||
for (char16_t ch : val)
|
||||
{
|
||||
utf8proc_uint8_t mb[4];
|
||||
utf8proc_ssize_t c = utf8proc_encode_char(utf8proc_int32_t(ch), mb);
|
||||
if (c < 0)
|
||||
{
|
||||
atWarning("invalid UTF-8 character while encoding");
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
ret->m_scalarString.append(reinterpret_cast<char*>(mb), c);
|
||||
}
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const char16_t* val)
|
||||
{
|
||||
std::u16string wstr(val);
|
||||
return ValToNode(wstr);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const std::u32string& val)
|
||||
{
|
||||
YAMLNode* ret = new YAMLNode(YAML_SCALAR_NODE);
|
||||
ret->m_scalarString.reserve(val.length());
|
||||
for (char32_t ch : val)
|
||||
{
|
||||
utf8proc_uint8_t mb[4];
|
||||
utf8proc_ssize_t c = utf8proc_encode_char(utf8proc_int32_t(ch), mb);
|
||||
if (c < 0)
|
||||
{
|
||||
atWarning("invalid UTF-8 character while encoding");
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
ret->m_scalarString.append(reinterpret_cast<char*>(mb), c);
|
||||
}
|
||||
return std::unique_ptr<YAMLNode>(ret);
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> ValToNode(const char32_t* val)
|
||||
{
|
||||
std::u32string wstr(val);
|
||||
return ValToNode(wstr);
|
||||
}
|
||||
|
||||
static const char* ErrorString(yaml_error_type_t errt)
|
||||
{
|
||||
switch (errt)
|
||||
|
|
@ -80,6 +535,30 @@ int YAMLAthenaWriter(athena::io::IStreamWriter* writer,
|
|||
return 1;
|
||||
}
|
||||
|
||||
YAMLDocWriter::YAMLDocWriter(const char* classType) : m_rootNode(YAML_MAPPING_NODE)
|
||||
{
|
||||
if (!yaml_emitter_initialize(&m_emitter))
|
||||
{
|
||||
HandleYAMLEmitterError(&m_emitter);
|
||||
return;
|
||||
}
|
||||
yaml_emitter_set_unicode(&m_emitter, true);
|
||||
yaml_emitter_set_width(&m_emitter, -1);
|
||||
|
||||
m_subStack.emplace_back(&m_rootNode);
|
||||
if (classType)
|
||||
{
|
||||
YAMLNode* classVal = new YAMLNode(YAML_SCALAR_NODE);
|
||||
classVal->m_scalarString.assign(classType);
|
||||
m_rootNode.m_mapChildren.emplace_back("DNAType", std::unique_ptr<YAMLNode>(classVal));
|
||||
}
|
||||
}
|
||||
|
||||
YAMLDocWriter::~YAMLDocWriter()
|
||||
{
|
||||
yaml_emitter_delete(&m_emitter);
|
||||
}
|
||||
|
||||
bool YAMLDocWriter::finish(athena::io::IStreamWriter* fout)
|
||||
{
|
||||
yaml_event_t event = {};
|
||||
|
|
@ -110,6 +589,222 @@ err:
|
|||
return false;
|
||||
}
|
||||
|
||||
void YAMLDocWriter::enterSubRecord(const char* name)
|
||||
{
|
||||
YAMLNode* curSub = m_subStack.back();
|
||||
if (curSub->m_type != YAML_MAPPING_NODE &&
|
||||
curSub->m_type != YAML_SEQUENCE_NODE)
|
||||
return;
|
||||
YAMLNode* newNode = new YAMLNode(YAML_MAPPING_NODE);
|
||||
if (curSub->m_type == YAML_MAPPING_NODE)
|
||||
curSub->m_mapChildren.emplace_back(name?std::string(name):std::string(), std::unique_ptr<YAMLNode>(newNode));
|
||||
else if (curSub->m_type == YAML_SEQUENCE_NODE)
|
||||
curSub->m_seqChildren.emplace_back(newNode);
|
||||
m_subStack.push_back(newNode);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::leaveSubRecord()
|
||||
{
|
||||
if (m_subStack.size() > 1)
|
||||
{
|
||||
YAMLNode* curSub = m_subStack.back();
|
||||
/* Automatically lower to scalar or sequence if there's only one unnamed node */
|
||||
if (curSub->m_mapChildren.size() == 1 &&
|
||||
curSub->m_mapChildren[0].first.empty())
|
||||
{
|
||||
auto& item = curSub->m_mapChildren[0];
|
||||
if (item.first.empty())
|
||||
{
|
||||
if (item.second->m_type == YAML_SCALAR_NODE)
|
||||
{
|
||||
curSub->m_type = YAML_SCALAR_NODE;
|
||||
curSub->m_scalarString = std::move(item.second->m_scalarString);
|
||||
curSub->m_mapChildren.clear();
|
||||
}
|
||||
else if (item.second->m_type == YAML_SEQUENCE_NODE)
|
||||
{
|
||||
curSub->m_type = YAML_SEQUENCE_NODE;
|
||||
curSub->m_seqChildren = std::move(item.second->m_seqChildren);
|
||||
curSub->m_mapChildren.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
m_subStack.pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
void YAMLDocWriter::enterSubVector(const char* name)
|
||||
{
|
||||
YAMLNode* curSub = m_subStack.back();
|
||||
if (curSub->m_type != YAML_MAPPING_NODE &&
|
||||
curSub->m_type != YAML_SEQUENCE_NODE)
|
||||
return;
|
||||
YAMLNode* newNode = new YAMLNode(YAML_SEQUENCE_NODE);
|
||||
if (curSub->m_type == YAML_MAPPING_NODE)
|
||||
curSub->m_mapChildren.emplace_back(name?std::string(name):std::string(), std::unique_ptr<YAMLNode>(newNode));
|
||||
else if (curSub->m_type == YAML_SEQUENCE_NODE)
|
||||
curSub->m_seqChildren.emplace_back(newNode);
|
||||
m_subStack.push_back(newNode);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::leaveSubVector()
|
||||
{
|
||||
if (m_subStack.size() > 1)
|
||||
m_subStack.pop_back();
|
||||
}
|
||||
|
||||
template <typename INTYPE>
|
||||
void YAMLDocWriter::writeVal(const char* name, const INTYPE& val)
|
||||
{
|
||||
YAMLNode* curSub = m_subStack.back();
|
||||
if (curSub->m_type == YAML_MAPPING_NODE)
|
||||
curSub->m_mapChildren.emplace_back(name?name:std::string(), std::move(ValToNode(val)));
|
||||
else if (curSub->m_type == YAML_SEQUENCE_NODE)
|
||||
curSub->m_seqChildren.emplace_back(std::move(ValToNode(val)));
|
||||
}
|
||||
|
||||
template <typename INTYPE>
|
||||
void YAMLDocWriter::writeVal(const char* name, const INTYPE& val, size_t byteCount)
|
||||
{
|
||||
YAMLNode* curSub = m_subStack.back();
|
||||
if (curSub->m_type == YAML_MAPPING_NODE)
|
||||
curSub->m_mapChildren.emplace_back(name?name:std::string(), std::move(ValToNode(val, byteCount)));
|
||||
else if (curSub->m_type == YAML_SEQUENCE_NODE)
|
||||
curSub->m_seqChildren.emplace_back(std::move(ValToNode(val, byteCount)));
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeBool(const char* name, const bool& val)
|
||||
{
|
||||
writeVal<bool>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeByte(const char* name, const atInt8& val)
|
||||
{
|
||||
writeVal<atInt8>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeUByte(const char* name, const atUint8& val)
|
||||
{
|
||||
writeVal<atUint8>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeInt16(const char* name, const atInt16& val)
|
||||
{
|
||||
writeVal<atInt16>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeUint16(const char* name, const atUint16& val)
|
||||
{
|
||||
writeVal<atUint16>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeInt32(const char* name, const atInt32& val)
|
||||
{
|
||||
writeVal<atInt32>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeUint32(const char* name, const atUint32& val)
|
||||
{
|
||||
writeVal<atUint32>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeInt64(const char* name, const atInt64& val)
|
||||
{
|
||||
writeVal<atInt64>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeUint64(const char* name, const atUint64& val)
|
||||
{
|
||||
writeVal<atUint64>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeFloat(const char* name, const float& val)
|
||||
{
|
||||
writeVal<float>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeDouble(const char* name, const double& val)
|
||||
{
|
||||
writeVal<double>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeVec2f(const char* name, const atVec2f& val)
|
||||
{
|
||||
writeVal<atVec2f>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeVec3f(const char* name, const atVec3f& val)
|
||||
{
|
||||
writeVal<atVec3f>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeVec4f(const char* name, const atVec4f& val)
|
||||
{
|
||||
writeVal<atVec4f>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeVec2d(const char* name, const atVec2d& val)
|
||||
{
|
||||
writeVal<atVec2d>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeVec3d(const char* name, const atVec3d& val)
|
||||
{
|
||||
writeVal<atVec3d>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeVec4d(const char* name, const atVec4d& val)
|
||||
{
|
||||
writeVal<atVec4d>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeUBytes(const char* name,
|
||||
const std::unique_ptr<atUint8[]>& val,
|
||||
size_t byteCount)
|
||||
{
|
||||
writeVal<const std::unique_ptr<atUint8[]>&>(name, val, byteCount);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeString(const char* name, const std::string& val)
|
||||
{
|
||||
writeVal<std::string>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeString(const char* name, const char* val)
|
||||
{
|
||||
writeVal<const char*>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeWString(const char* name, const std::wstring& val)
|
||||
{
|
||||
writeVal<std::wstring>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeWString(const char* name, const wchar_t* val)
|
||||
{
|
||||
writeVal<const wchar_t*>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeU16String(const char* name, const std::u16string& val)
|
||||
{
|
||||
writeVal<std::u16string>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeU16String(const char* name, const char16_t* val)
|
||||
{
|
||||
writeVal<const char16_t*>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeU32String(const char* name, const std::u32string& val)
|
||||
{
|
||||
writeVal<std::u32string>(name, val);
|
||||
}
|
||||
|
||||
void YAMLDocWriter::writeU32String(const char* name, const char32_t* val)
|
||||
{
|
||||
writeVal<const char32_t*>(name, val);
|
||||
}
|
||||
|
||||
static inline void InsertNode(std::vector<YAMLNode*>& nodeStack,
|
||||
std::unique_ptr<YAMLNode>& mapKey,
|
||||
std::unique_ptr<YAMLNode>& retVal,
|
||||
|
|
@ -215,6 +910,38 @@ std::unique_ptr<YAMLNode> YAMLDocReader::ParseEvents(athena::io::IStreamReader*
|
|||
return std::unique_ptr<YAMLNode>();
|
||||
}
|
||||
|
||||
YAMLDocReader::YAMLDocReader()
|
||||
{
|
||||
if (!yaml_parser_initialize(&m_parser))
|
||||
{
|
||||
HandleYAMLParserError(&m_parser);
|
||||
return;
|
||||
}
|
||||
}
|
||||
YAMLDocReader::~YAMLDocReader()
|
||||
{
|
||||
yaml_parser_delete(&m_parser);
|
||||
}
|
||||
|
||||
void YAMLDocReader::reset()
|
||||
{
|
||||
yaml_parser_delete(&m_parser);
|
||||
if (!yaml_parser_initialize(&m_parser))
|
||||
HandleYAMLParserError(&m_parser);
|
||||
}
|
||||
|
||||
bool YAMLDocReader::parse(athena::io::IStreamReader* reader)
|
||||
{
|
||||
std::unique_ptr<YAMLNode> newRoot = ParseEvents(reader);
|
||||
if (!newRoot)
|
||||
return false;
|
||||
m_rootNode = std::move(newRoot);
|
||||
m_subStack.clear();
|
||||
m_subStack.push_back(m_rootNode.get());
|
||||
m_seqTrackerStack.clear();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool YAMLDocReader::ClassTypeOperation(std::function<bool(const char* dnaType)> func)
|
||||
{
|
||||
yaml_event_t event;
|
||||
|
|
@ -289,6 +1016,215 @@ bool YAMLDocReader::ValidateClassType(const char* expectedType)
|
|||
});
|
||||
}
|
||||
|
||||
bool YAMLDocReader::enterSubRecord(const char* name)
|
||||
{
|
||||
YAMLNode* curSub = m_subStack.back();
|
||||
if (curSub->m_type == YAML_SEQUENCE_NODE)
|
||||
{
|
||||
int& seqIdx = m_seqTrackerStack.back();
|
||||
m_subStack.push_back(curSub->m_seqChildren[seqIdx++].get());
|
||||
if (m_subStack.back()->m_type == YAML_SEQUENCE_NODE)
|
||||
m_seqTrackerStack.push_back(0);
|
||||
return true;
|
||||
}
|
||||
for (const auto& item : curSub->m_mapChildren)
|
||||
{
|
||||
if (!item.first.compare(name))
|
||||
{
|
||||
m_subStack.push_back(item.second.get());
|
||||
if (m_subStack.back()->m_type == YAML_SEQUENCE_NODE)
|
||||
m_seqTrackerStack.push_back(0);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void YAMLDocReader::leaveSubRecord()
|
||||
{
|
||||
if (m_subStack.size() > 1)
|
||||
{
|
||||
if (m_subStack.back()->m_type == YAML_SEQUENCE_NODE)
|
||||
m_seqTrackerStack.pop_back();
|
||||
m_subStack.pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
bool YAMLDocReader::enterSubVector(const char* name, size_t& countOut)
|
||||
{
|
||||
YAMLNode* curSub = m_subStack.back();
|
||||
if (!name && curSub->m_type == YAML_SEQUENCE_NODE)
|
||||
{
|
||||
m_subStack.push_back(curSub);
|
||||
m_seqTrackerStack.push_back(0);
|
||||
countOut = curSub->m_seqChildren.size();
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (const auto& item : curSub->m_mapChildren)
|
||||
{
|
||||
if (!item.first.compare(name))
|
||||
{
|
||||
YAMLNode* nextSub = item.second.get();
|
||||
if (nextSub->m_type == YAML_SEQUENCE_NODE)
|
||||
{
|
||||
countOut = nextSub->m_seqChildren.size();
|
||||
}
|
||||
else
|
||||
{
|
||||
atError("'%s' is not a vector field", name);
|
||||
countOut = 0;
|
||||
}
|
||||
m_subStack.push_back(nextSub);
|
||||
m_seqTrackerStack.push_back(0);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
countOut = 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
void YAMLDocReader::leaveSubVector()
|
||||
{
|
||||
if (m_subStack.size() > 1)
|
||||
{
|
||||
m_subStack.pop_back();
|
||||
m_seqTrackerStack.pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
template <typename RETURNTYPE>
|
||||
RETURNTYPE YAMLDocReader::readVal(const char* name)
|
||||
{
|
||||
if (m_subStack.size())
|
||||
{
|
||||
const YAMLNode* mnode = m_subStack.back();
|
||||
if (mnode->m_type == YAML_SCALAR_NODE)
|
||||
{
|
||||
return NodeToVal<RETURNTYPE>(mnode);
|
||||
}
|
||||
else if (mnode->m_type == YAML_SEQUENCE_NODE)
|
||||
{
|
||||
int& seqIdx = m_seqTrackerStack.back();
|
||||
return NodeToVal<RETURNTYPE>(mnode->m_seqChildren[seqIdx++].get());
|
||||
}
|
||||
else if (mnode->m_type == YAML_MAPPING_NODE && name)
|
||||
{
|
||||
for (const auto& item : mnode->m_mapChildren)
|
||||
{
|
||||
if (!item.first.compare(name))
|
||||
{
|
||||
return NodeToVal<RETURNTYPE>(item.second.get());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (name)
|
||||
atWarning("Unable to find field '%s'; returning 0", name);
|
||||
return RETURNTYPE();
|
||||
}
|
||||
|
||||
bool YAMLDocReader::readBool(const char* name)
|
||||
{
|
||||
return readVal<bool>(name);
|
||||
}
|
||||
|
||||
atInt8 YAMLDocReader::readByte(const char* name)
|
||||
{
|
||||
return readVal<atInt8>(name);
|
||||
}
|
||||
|
||||
atUint8 YAMLDocReader::readUByte(const char* name)
|
||||
{
|
||||
return readVal<atUint8>(name);
|
||||
}
|
||||
|
||||
atInt16 YAMLDocReader::readInt16(const char* name)
|
||||
{
|
||||
return readVal<atInt16>(name);
|
||||
}
|
||||
|
||||
atUint16 YAMLDocReader::readUint16(const char* name)
|
||||
{
|
||||
return readVal<atUint16>(name);
|
||||
}
|
||||
|
||||
atInt32 YAMLDocReader::readInt32(const char* name)
|
||||
{
|
||||
return readVal<atInt32>(name);
|
||||
}
|
||||
|
||||
atUint32 YAMLDocReader::readUint32(const char* name)
|
||||
{
|
||||
return readVal<atUint32>(name);
|
||||
}
|
||||
|
||||
atInt64 YAMLDocReader::readInt64(const char* name)
|
||||
{
|
||||
return readVal<atInt64>(name);
|
||||
}
|
||||
|
||||
atUint64 YAMLDocReader::readUint64(const char* name)
|
||||
{
|
||||
return readVal<atUint64>(name);
|
||||
}
|
||||
|
||||
float YAMLDocReader::readFloat(const char* name)
|
||||
{
|
||||
return readVal<float>(name);
|
||||
}
|
||||
|
||||
double YAMLDocReader::readDouble(const char* name)
|
||||
{
|
||||
return readVal<double>(name);
|
||||
}
|
||||
|
||||
atVec2f YAMLDocReader::readVec2f(const char* name)
|
||||
{
|
||||
return readVal<atVec2f>(name);
|
||||
}
|
||||
|
||||
atVec3f YAMLDocReader::readVec3f(const char* name)
|
||||
{
|
||||
return readVal<atVec3f>(name);
|
||||
}
|
||||
atVec4f YAMLDocReader::readVec4f(const char* name)
|
||||
{
|
||||
return readVal<atVec4f>(name);
|
||||
}
|
||||
|
||||
atVec2d YAMLDocReader::readVec2d(const char* name)
|
||||
{
|
||||
return readVal<atVec2d>(name);
|
||||
}
|
||||
|
||||
atVec3d YAMLDocReader::readVec3d(const char* name)
|
||||
{
|
||||
return readVal<atVec3d>(name);
|
||||
}
|
||||
|
||||
atVec4d YAMLDocReader::readVec4d(const char* name)
|
||||
{
|
||||
return readVal<atVec4d>(name);
|
||||
}
|
||||
|
||||
std::unique_ptr<atUint8[]> YAMLDocReader::readUBytes(const char* name)
|
||||
{
|
||||
return readVal<std::unique_ptr<atUint8[]>>(name);
|
||||
}
|
||||
|
||||
std::string YAMLDocReader::readString(const char* name)
|
||||
{
|
||||
return readVal<std::string>(name);
|
||||
}
|
||||
|
||||
std::wstring YAMLDocReader::readWString(const char* name)
|
||||
{
|
||||
return readVal<std::wstring>(name);
|
||||
}
|
||||
|
||||
static inline bool EmitKeyScalar(yaml_emitter_t* doc, const char* val)
|
||||
{
|
||||
yaml_event_t event;
|
||||
|
|
|
|||
Loading…
Reference in New Issue