config.cpp

#include "config.h"
#include "debug.h"
#include "fast_atof.h"

using namespace irr;
using namespace core;
using namespace io;

extern Debug* dbg;

Config::Config(IrrlichtDevice* d)
{
    //ctor
    dbg->log("create Config");
    device = d;
}

Config::~Config()
{
    //dtor
    // erase all parameters
    s32 count = getParameterCount();

    for (s32 i=0; i<count; i++)
    {
        setParameter(getParameterName(i), 0);
    }
    Parameters.clear();
    dbg->log("Config deleted");
}

void Config::loadConfig(c8* fileName)
{
    dbg->log("loadConfig", fileName);
    // read configuration from xml file
    IXMLReaderUTF8* xml = device->getFileSystem()->createXMLReaderUTF8(fileName);

    while(xml && xml->read())
    {
        switch (xml->getNodeType())
        {
                case EXN_ELEMENT:
            {
                const c8* nodeData = xml->getNodeData();
                const c8* nodeName = xml->getNodeName();

                s32 count = xml->getAttributeCount();
                for (s32 i=0; i<count; i++)
                {
                    const c8* name = xml->getAttributeName(i);
                    const c8* stringValue = xml->getAttributeValue(i);
                    if (name && stringValue)
                    {
                        setParameter(name, stringValue);
                    }
                }
            }
            break;
        }
    }
    if (xml)
    {
        xml->drop();
    }
    else
    {
        dbg->log("cannot load config", fileName);
    }
}

void Config::safeConfig(c8* description, c8* fileName)
{
    dbg->log("safeConfig", fileName);
    IXMLWriter* xml = device->getFileSystem()->createXMLWriter(fileName);
    xml->writeXMLHeader();
    stringw lineBreak("\r\n");
    xml->writeText(lineBreak.c_str());

    stringw element(description);
    s32 count = getParameterCount();

    for (s32 i=0; i<count; i++)
    {
        stringw name(getParameterName(i));
        stringw value(getParameterValue(i));
        xml->writeElement(element.c_str(), true, name.c_str(), value.c_str());
        xml->writeText(lineBreak.c_str());
    }
    if (xml)
    {
        xml->drop();
    }
    else
    {
        dbg->log("cannot safe config", fileName);
    }
}

void Config::safeDefaultConfig(const c8* fileName)
{
    dbg->log("safeDefaultConfig", fileName);
    IXMLWriter* xml = device->getFileSystem()->createXMLWriter(fileName);
    xml->writeXMLHeader();

    stringw lineBreak("\r\n");
    xml->writeText(lineBreak.c_str());

    stringw element, name, value;

    element = "CONFIG";
    name = "SCREEN_X";
    value = "800";
    xml->writeElement(element.c_str(), true, name.c_str(), value.c_str());
    xml->writeText(lineBreak.c_str());

    name = "SCREEN_Y";
    value ="600";
    xml->writeElement(element.c_str(), true, name.c_str(), value.c_str());
    xml->writeText(lineBreak.c_str());

    name = "FULLSCREEN";
    value = "0";
    xml->writeElement(element.c_str(), true, name.c_str(), value.c_str());
    xml->writeText(lineBreak.c_str());

    name = "BITDEPTH";
    value = "16";
    xml->writeElement(element.c_str(), true, name.c_str(), value.c_str());
    xml->writeText(lineBreak.c_str());

    if (xml)
    {
        xml->drop();
    }
    else
    {
        dbg->log("cannot safe default config", fileName);
    }
}

void Config::setParameter(const c8* parameterName, const c8* value)
{
        for (int i=0; i<(int)Parameters.size(); ++i)
                if (Parameters[i].Name == parameterName)
                {
                        if (!value)
                                Parameters.erase(i);
                        else
                                Parameters[i].Value = value;
                        return;
                }

        if (value)
        {
                Parameters.push_back(SStringPair());
                Parameters.getLast().Name = parameterName;
                Parameters.getLast().Value = value;
        }
}

const c8* Config::getParameter(const c8* parameterName)
{
        for (int i=0; i<(int)Parameters.size(); ++i)
                if (Parameters[i].Name == parameterName)
                        return Parameters[i].Value.c_str();

        return 0;
}

Config::SStringPair* Config::getParameterP(const c8* parameterName)
{
        for (int i=0; i<(int)Parameters.size(); ++i)
                if (Parameters[i].Name == parameterName)
                        return &Parameters[i];

        return 0;
}


void Config::setParameter(const c8* parameterName, bool value)
{
        setParameter(parameterName, value ? "true" : "false");
}

bool Config::getParameterAsBool(const c8* parameterName)
{
        bool ret = false;

        SStringPair* p = getParameterP(parameterName);
        if (p)
                ret = (p->Value == "true");

        _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
        return ret;
}

void Config::setParameter(const c8* parameterName, s32 value)
{
        core::stringc s = value;
        setParameter(parameterName, s.c_str());
}

s32 Config::getParameterAsInt(const c8* parameterName)
{
        return (s32)getParameterAsFloat(parameterName);
}

void Config::setParameter(const c8* parameterName, f32 value)
{
        char tmp[32];
        sprintf(tmp, "%f", value);
        setParameter(parameterName, tmp);
}

f32 Config::getParameterAsFloat(const c8* parameterName)
{
        SStringPair* p = getParameterP(parameterName);
        if (!p)
                return false;

        return core::fast_atof(p->Value.c_str());
}


s32 Config::getParameterCount()
{
        return Parameters.size();
}

const c8* Config::getParameterName(s32 index)
{
        if (index < 0 || index >= (int)Parameters.size())
                return 0;

        return Parameters[index].Name.c_str();
}

const c8* Config::getParameterValue(s32 index)
{
        if (index < 0 || index >= (int)Parameters.size())
                return 0;

        return Parameters[index].Value.c_str();
}

---