XmlNode.h

Go to the documentation of this file.

/*
* Copyright 2017 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

#pragma once

#include "gwnavruntime/base/kyguid.h"
#include "gwnavruntime/containers/kyarray.h"
#include "gwnavruntime/database/navtag.h"
#include "gwnavruntime/kernel/SF_String.h"
#include "gwnavruntime/math/vec3f.h"
#include "gwnavruntime/navmesh/navmeshtypes.h"
#include "gwnavruntime/visualsystem/color.h"
#include <string>
#include <vector>
#include "navgenproj/TiXml.h"

namespace Kaim
{

class XmlNode
{
public:
    explicit XmlNode(TiXmlNode* node) : m_node(node) {}

    // usage: for (XmlNode child = node.FirstChild(); child; child = child.NextSibling())
    XmlNode FirstChild() const { return XmlNode(TiXml::FirstChild(m_node)); }
    XmlNode NextSibling() const { return XmlNode(TiXml::NextSibling(m_node)); }

    bool IsValid() const { return m_node != nullptr; }
    operator bool() const { return m_node != nullptr; }

    bool IsElement() const { return TiXml::IsElement(m_node); }

    bool HasName(const char* name) const { return m_node ? TiXml::HasName(m_node, name) : false; }

    const char* GetName() const { return m_node ? TiXml::GetName(m_node) : nullptr; }

    bool HasValue() const { return TiXml::HasValue(m_node); }

    bool HasValue(const char* name) const { return TiXml::HasValue(m_node, name); }

    const char* GetValue() const { return TiXml::GetValue(m_node); }

    void CreateValue(XmlNode node, const char* value) { TiXml::CreateValue(node.m_node, value); }

    XmlNode CreateChild(const char* name) { return XmlNode(TiXml::CreateChild(m_node, name)); }

    XmlNode GetChild(const char* name) { return m_node ? XmlNode(TiXml::GetChild(m_node, name)) : XmlNode(nullptr); }

    template<typename T>
    bool ReadNode(T& value) { return m_node ? Read(*this, value) : false; }

    template<typename T, typename U>
    bool ReadNode(T& value, const U& enumNames) { return m_node ? Read(*this, value, enumNames) : false; }

    template<typename T>
    void WriteNode(const T& value) { Write(*this, value); }

    template<typename T, typename U>
    void WriteNode(const T& value, const U& enumNames) { Write(*this, value, enumNames); }

    template<typename T>
    bool ReadChild(const char* name, T& value) { return GetChild(name).ReadNode(value); }

    template<typename T, typename U>
    bool ReadChild(const char* name, T& value, const U& enumNames) { return GetChild(name).ReadNode(value, enumNames); }

    template<typename T>
    void WriteChild(const char* name, const T& value) { CreateChild(name).WriteNode(value); }

    template<typename T, typename U>
    void WriteChild(const char* name, const T& value, const U& enumNames) { CreateChild(name).WriteNode(value, enumNames); }

public:
    TiXmlNode* m_node;
};


#define KY_READ_CHILD_VALUE(child_, name_, value_) \
{ \
    if (child_.HasName(name_)) \
    { \
        if (Kaim::Read(child_, value_) == false) \
        { \
            KY_LOG_ERROR(("[NavGenProj] Read <%s> FAILED", name_)); \
            return false; \
        } \
        continue; \
    } \
}


#define KY_READ_CHILD_ENUM(child_, name_, value_, enumNames_) \
{ \
    if (child_.HasName(name_)) \
    { \
        if (Kaim::Read(child_, value_, enumNames_) == false) \
        { \
            KY_LOG_ERROR(("[NavGenProj] Read <%s> FAILED", name_)); \
            return false; \
        } \
        continue; \
    } \
}

#define KY_READ_CHILD_FUNC(child_, name_, func_) \
{ \
    if (child_.HasName(name_)) \
    { \
        if ((func_) == false) \
        { \
            KY_LOG_ERROR(("[NavGenProj] Read <%s> FAILED", name_)); \
            return false; \
        } \
        continue; \
    } \
}


class XmlDoc
{
public:
    XmlDoc(const char* path) { m_doc = TiXml::CreateDoc(path); }
    XmlNode Root() { return XmlNode((TiXmlNode*)m_doc); }
    bool Load() { return TiXml::LoadDoc(m_doc); }
    bool Save() { return TiXml::SaveDoc(m_doc); }
    ~XmlDoc() { TiXml::DestroyDoc(m_doc); }
public:
    TiXmlDocument* m_doc;
};

}