Registry.cpp

#include "ECF_base.h"
 
 
bool Registry::registerEntry(std::string key, voidP x, enum ECF::type T, std::string description, uint index)
{
    ParamP a = (ParamP) new ECF::Param;
    a->value= x;
    a->T = T;
    a->description = description;
    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(XMLNode& xRegistry) 
{
    xRegistry = XMLNode::createXMLTopNode(NODE_REGISTRY);
 
    for (map_iter it = parameters_.begin(); it != parameters_.end(); ++it) {
 
        XMLNode xParam = XMLNode::createXMLTopNode(NODE_ENTRY);
        std::string key   = it->first;
        voidP       value = it->second->value;
        ECF::type   T     = it->second->T;
        std::string desc  = it->second->description;
 
        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());
        xParam.addAttribute("desc", desc.c_str());
        xRegistry.addChild(xParam);
 
        //if(desc != "")
        //  xRegistry.addClear(desc.c_str(), "<!-- ", " -->");
    }   
}