xml.cpp

Go to the documentation of this file.

 
/*
Copyright (C) 2002-2022 UFO: Alien Invasion.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
*/
 
#include "xml.h"
#include "../shared/cxx.h"
#include "../shared/shared.h"
 
void XML_AddString (xmlNode_t* parent, const char* name, const char* value)
{
    if (value)
        mxmlElementSetAttr(parent, name, value);
}
 
void XML_AddStringValue (xmlNode_t* parent, const char* name, const char* value)
{
    if (Q_strnull(value))
        return;
    XML_AddString(parent, name, value);
}
 
void XML_AddBool (xmlNode_t* parent, const char* name, bool value)
{
    mxmlElementSetAttr(parent, name, value ? "true" : "false");
}
 
void XML_AddBoolValue (xmlNode_t* parent, const char* name, bool value)
{
    if (!value)
        return;
    XML_AddBool(parent, name, value);
}
 
void XML_AddFloat (xmlNode_t* parent, const char* name, float value)
{
    XML_AddDouble(parent, name, value);
}
 
void XML_AddFloatValue (xmlNode_t* parent, const char* name, float value)
{
    XML_AddDoubleValue(parent, name, value);
}
 
void XML_AddDouble (xmlNode_t* parent, const char* name, double value)
{
    char txt[50];
    snprintf(txt, sizeof(txt), "%f", value);
    mxmlElementSetAttr(parent, name, txt);
}
 
void XML_AddDoubleValue (xmlNode_t* parent, const char* name, double value)
{
    if (value) {
        XML_AddDouble(parent, name, value);
    }
}
 
void XML_AddByte (xmlNode_t* parent, const char* name, byte value)
{
    XML_AddLong(parent, name, value);
}
 
void XML_AddByteValue (xmlNode_t* parent, const char* name, byte value)
{
    XML_AddLongValue(parent, name, value);
}
 
void XML_AddShort (xmlNode_t* parent, const char* name, short value)
{
    XML_AddLong(parent, name, value);
}
 
void XML_AddShortValue (xmlNode_t* parent, const char* name, short value)
{
    XML_AddLongValue(parent, name, value);
}
 
void XML_AddInt (xmlNode_t* parent, const char* name, int value)
{
    XML_AddLong(parent, name, value);
}
 
void XML_AddIntValue (xmlNode_t* parent, const char* name, int value)
{
    XML_AddLongValue(parent, name, value);
}
 
void XML_AddLong (xmlNode_t* parent, const char* name, long value)
{
    char txt[50];
    snprintf(txt, sizeof(txt), "%ld", value);
    mxmlElementSetAttr(parent, name, txt);
}
 
void XML_AddLongValue (xmlNode_t* parent, const char* name, long value)
{
    if (!value)
        return;
    XML_AddLong(parent, name, value);
}
 
void XML_AddPos3 (xmlNode_t* parent, const char* name, const vec3_t pos)
{
    xmlNode_t* t = mxmlNewElement(parent, name);
    XML_AddFloat(t, "x", pos[0]);
    XML_AddFloat(t, "y", pos[1]);
    XML_AddFloat(t, "z", pos[2]);
}
 
void XML_AddPos2 (xmlNode_t* parent, const char* name, const vec2_t pos)
{
    xmlNode_t* t = mxmlNewElement(parent, name);
    XML_AddFloat(t, "x", pos[0]);
    XML_AddFloat(t, "y", pos[1]);
}
 
void XML_AddDate (xmlNode_t* parent, const char* name, const int day, const int sec)
{
    xmlNode_t* t = mxmlNewElement(parent, name);
    XML_AddInt(t, "day", day);
    XML_AddInt(t, "sec", sec);
}
 
xmlNode_t* XML_AddNode (xmlNode_t* parent, const char* name)
{
    return mxmlNewElement(parent,name);
}
 
bool XML_GetBool (xmlNode_t* parent, const char* name, const bool defaultval)
{
    const char* txt = mxmlElementGetAttr(parent, name);
    if (!txt)
        return defaultval;
 
    if (Q_streq(txt, "true") || Q_streq(txt, "1"))
        return true;
    if (Q_streq(txt, "false") || Q_streq(txt, "0"))
        return false;
 
    return defaultval;
}
 
int XML_GetInt (xmlNode_t* parent, const char* name, const int defaultval)
{
    const char* txt = mxmlElementGetAttr(parent, name);
    if (!txt)
        return defaultval;
    return atoi(txt);
}
 
short XML_GetShort (xmlNode_t* parent, const char* name, const short defaultval)
{
    const char* txt = mxmlElementGetAttr(parent, name);
    if (!txt)
        return defaultval;
    return atoi(txt);
}
 
long XML_GetLong (xmlNode_t* parent, const char* name, const long defaultval)
{
    const char* txt = mxmlElementGetAttr(parent, name);
    if (!txt)
        return defaultval;
    return atol(txt);
}
 
const char*  XML_GetString (xmlNode_t* parent, const char* name)
{
    const char* str = mxmlElementGetAttr(parent, name);
    if (!str)
        return "";
    return str;
}
 
float XML_GetFloat (xmlNode_t* parent, const char* name, const float defaultval)
{
    const char* txt = mxmlElementGetAttr(parent, name);
    if (!txt)
        return defaultval;
    return atof(txt);
}
 
double XML_GetDouble (xmlNode_t* parent, const char* name, const double defaultval)
{
    const char* txt = mxmlElementGetAttr(parent, name);
    if (!txt)
        return defaultval;
    return atof(txt);
}
 
xmlNode_t* XML_GetPos2 (xmlNode_t* parent, const char* name, vec2_t pos)
{
    xmlNode_t* p = XML_GetNode(parent, name);
    if (!p)
        return nullptr;
    pos[0] = XML_GetFloat(p, "x", 0);
    pos[1] = XML_GetFloat(p, "y", 0);
    return p;
}
 
xmlNode_t* XML_GetNextPos2 (xmlNode_t* actual, xmlNode_t* parent, const char* name, vec2_t pos)
{
    xmlNode_t* p = XML_GetNextNode(actual, parent, name);
    if (!p)
        return nullptr;
    pos[0] = XML_GetFloat(p, "x", 0);
    pos[1] = XML_GetFloat(p, "y", 0);
    return p;
}
 
xmlNode_t* XML_GetPos3 (xmlNode_t* parent, const char* name, vec3_t pos)
{
    xmlNode_t* p = XML_GetNode(parent, name);
    if (!p)
        return nullptr;
    pos[0] = XML_GetFloat(p, "x", 0);
    pos[1] = XML_GetFloat(p, "y", 0);
    pos[2] = XML_GetFloat(p, "z", 0);
    return p;
}
 
xmlNode_t* XML_GetNextPos3 (xmlNode_t* actual, xmlNode_t* parent, const char* name, vec3_t pos)
{
    xmlNode_t* p = XML_GetNextNode(actual, parent, name);
    if (!p)
        return nullptr;
    pos[0] = XML_GetFloat(p, "x", 0);
    pos[1] = XML_GetFloat(p, "y", 0);
    pos[2] = XML_GetFloat(p, "z", 0);
    return p;
}
 
xmlNode_t* XML_GetDate (xmlNode_t* parent, const char* name, int* day, int* sec)
{
    xmlNode_t* p = XML_GetNode(parent, name);
    if (!p)
        return nullptr;
    *day = XML_GetInt(p, "day", 0);
    *sec = XML_GetInt(p, "sec", 0);
    return p;
}
 
xmlNode_t* XML_GetNode (xmlNode_t* parent, const char* name)
{
    return mxmlFindElement(parent, parent, name, nullptr, nullptr, MXML_DESCEND_FIRST);
}
 
xmlNode_t* XML_GetNextNode (xmlNode_t* current, xmlNode_t* parent, const char* name)
{
    return mxmlFindElement(current, parent, name, nullptr, nullptr, MXML_NO_DESCEND);
}
 
static mxml_type_t mxml_ufo_type_cb (xmlNode_t* node)
{
    /* You can lookup attributes and/or use the
     * element name, hierarchy, etc... */
    const char* type = mxmlElementGetAttr(node, "type");
    if (type == nullptr) {
#ifdef MXML_MAJOR_VERSION
        type = mxmlGetElement(node);
#else
        type = node->value.element.name;
#endif
    }
 
    if (Q_streq(type, "int"))
        return MXML_INTEGER;
    else if (Q_streq(type, "opaque"))
        return MXML_OPAQUE;
    else if (Q_streq(type, "string"))
        return MXML_OPAQUE;
    else if (Q_streq(type, "double"))
        return MXML_REAL;
    return MXML_TEXT;
}
 
xmlNode_t* XML_Parse (const char* buffer)
{
    return mxmlLoadString(nullptr, buffer, mxml_ufo_type_cb);
}