D:/Projekt/ECF_trunk/ECF/Registry.cpp

#include "ECF_base.h"


bool Registry::registerEntry(std::string key, voidP x, enum ECF::type T, uint index)
{
    ParamP a = (ParamP) new ECF::Param;
    a->value= x;
    a->T = T;
    a->bModified=false;

    if(index > 0) 
        key = uint2str(index) + key;

    map_iter it = parameters_.find(key);
    if(it != parameters_.end())
        return false;

    parameters_.insert (std::pair < std::string, ParamP >(key, a));
    return true;
}


bool Registry::isRegistered(std::string key)
{
    return parameters_.find(key) != parameters_.end();
}


bool Registry::modifyEntry(std::string key, voidP x, uint index)
{
    if(index > 0) 
        key = uint2str(index) + key;

    map_iter it = parameters_.find(key);
    if(it != parameters_.end()) {
        it->second->value=x;
        it->second->bModified=true;
        return true;
    }
    else
        return false;
}


voidP Registry::getEntry(std::string key, uint index)
{
    if(index > 0) 
        key = uint2str(index) + key;

    map_iter iter = parameters_.find(key);

    if (iter != parameters_.end())
        return iter->second->value;

    voidP p;
    return p;
}


ECF::type Registry::getType(std::string key)
{
    map_iter iter = parameters_.find(key);
    if (iter != parameters_.end())
        return iter->second->T;

    return ECF::ERROR;
}


bool Registry::isModified(std::string key, uint index)
{
    if(index > 0) 
        key = uint2str(index) + key;

    map_iter iter = parameters_.find(key);

    if (iter != parameters_.end())
        return iter->second->bModified;

    return false;
}


bool Registry::readEntries(const XMLNode& node, std::string prefix, uint index)
{
    int num = node.nChildNode(NODE_ENTRY), iter = 0;

    for (int i = 0; i < num; ++i) {
        XMLNode child = node.getChildNode(NODE_ENTRY, &iter);
        if(!child.getAttribute("key")) {
            std::cerr << "Error: no attribute 'key' in current entry! (node '" << node.getName() << "')" << std::endl;
            return false;
        }

        std::string  key   = (prefix.length() > 0 ? prefix + "." : "") + child.getAttribute("key");
        if (child.getText() == NULL) {
            std::cerr << "Error: no text in Entry node! (key: " << key << ")" << std::endl;
            return false;
        }
        std::string  value = child.getText();

        if (index > 0)
            key = uint2str(index) + key;

        if (!isRegistered(key)) {
            std::cerr << "Warning: key " << key << " not registered." << std::endl;
            continue;
        }

        ECF::type t = getType(key);
        voidP new_value;

        bool ok = true;
        switch (t) {
            case ECF::INT:
                {
                    int *x = new int;
                    *x = str2int(value);
                    new_value = (voidP)x;

                    break;
                }
            case ECF::UINT:
                {
                    uint *x = new uint;
                    *x = str2uint(value);
                    new_value = (voidP)x;

                    break;
                }
            case ECF::STRING:
                {
                    std::string *s = new std::string(value);
                    new_value = (voidP)s;
                    break;
                }
            case ECF::FLOAT:
                {
                    float *x = new float;
                    *x = str2flt(value);
                    new_value = (voidP)x;

                    break;
                }
            case ECF::DOUBLE:
                {

                    double *x = new double;
                    *x = str2dbl(value);
                    new_value = (voidP)x;

                    break;
                }
            case ECF::CHAR:
                {
                    char *x = new char;
                    *x = value[0];
                    new_value = (voidP)x;

                    break;
                }
            default:
                ok = false;
                break;
        }

        if (ok)
            modifyEntry(key, new_value);
    }

    return true;
}


void Registry::write(XMLNode& xRegistry)
{
    xRegistry = XMLNode::createXMLTopNode(NODE_REGISTRY);

    for (map_iter it = parameters_.begin(); it != parameters_.end(); ++it) {

        if(!it->second->bModified)
            continue;

        XMLNode xParam = XMLNode::createXMLTopNode(NODE_ENTRY);
        std::string key   = it->first;
        voidP       value = it->second->value;
        ECF::type   T     = it->second->T;
        std::stringstream ss;

        switch (T) {
            case ECF::INT:
                ss << *((int *)value.get());
                break;
            case ECF::UINT:
                ss << *((uint *)value.get());
                break;
            case ECF::STRING:
                ss << *((std::string *)value.get());
                break;
            case ECF::FLOAT:
                ss << *((float *)value.get());
                break;
            case ECF::DOUBLE:
                ss << *((double *)value.get());
                break;
            case ECF::CHAR:
                ss << *((char *)value.get());
                break;
            default:
                break;
        }
        xParam.addAttribute("key", key.c_str());
        xParam.addText(ss.str().c_str());
        xRegistry.addChild(xParam);
    }
}


void Registry::dumpEntries(std::ostream &os) 
{
    for (map_iter it = parameters_.begin(); it != parameters_.end(); ++it) {
        std::string key   = it->first;
        voidP       value = it->second->value;
        ECF::type   T     = it->second->T;
        
        os << key << "=";
        switch (T) {
            case ECF::INT:
                os << *((int *)value.get());
                break;
            case ECF::UINT:
                os << *((uint *)value.get());
                break;
            case ECF::STRING:
                os << *((std::string *)value.get());
                break;
            case ECF::FLOAT:
                os << *((float *)value.get());
                break;
            case ECF::DOUBLE:
                os << *((double *)value.get());
                break;
            case ECF::CHAR:
                os << *((char *)value.get());
                break;
            default:
                break;
        }
        os << std::endl;
    }   
}