context.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Ilya A. Volynets-Evenbakh                       *
 *   ilya@total-knowledge.com                                              *
 *                                                                         *
 *   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 <serverconfig/serverconfig.h>
#include <iostream>
#include <algorithm>

namespace container {
namespace serverconfig {

Context::~Context()
{
    for(ctxlist_t::iterator it=m_kids.begin(); it!=m_kids.end(); it++) {
        delete *it;
    }
}

bool Context::process(ServerConfig& cfg, ConfigNode* node)
{
    m_name=node->getName();
    m_type=node->getType();
    ConfigNode::childlist_t kids = cfg.getNodes(node);
    for(ConfigNode::childlist_t::iterator it=kids.begin();
        it!=kids.end(); it++)
    {
        Context* ctx=getContext(**it);
        if(ctx) {
            addChildContext(ctx);
            if(!ctx->process(cfg, *it)) {
                std::cerr<< "Error loading context "<<ctx->getName()<<std::endl;
                return false;
            }
        } else {
            if(!setParam(**it)) {
                std::cerr<<"Failed setting parameter "<<(*it)->getType()
                    <<" In context "<<getName()<<" of type "<<getType()<<std::endl;
                return false;
            }
        }
    }
    return true;
}


void Context::addChildContext(Context* ctx)
{
    m_kids.push_back(ctx);
}

class NodeNameComparator
{
    std::string m_search;
public:
    NodeNameComparator(const std::string& s) :m_search(s){}
    bool operator()(const ConfigNode& node)
    { return node.getName()==m_search;}
};

bool Context::CfgParamList::add(const ConfigNode& node)
{
    if(m_flags&PARAM_SINGLE_OF_TYPE && ! empty()) {
        std::cerr<<"Error: parameter of type "<<node.getType()<<" was already set";
        return false;
    }
    if(m_flags&PARAM_SINGLE_OF_NAME &&
        std::find_if(begin(),end(),NodeNameComparator(node.getName()))!=end())
    {
        std::cerr<<"Error: parameter with name"<<node.getName()<<" was already set";
        return false;
    }
    push_back(node);
    return true;
}

bool Context::setParam(const ConfigNode& node)
{
    cfgparamlist_t &params=this->m_params[node.getType()];
    unsetparams_t& unsetParams=getUnsetParams();
    unsetparams_t::iterator it=unsetParams.find(node.getType());
    if(it!=unsetParams.end()) {
        params.m_flags=it->second.flags();
        unsetParams.erase(it);
    }
    if(params.add(node))
        return onSetParam(node);
    std::cerr<<"Error setting paramter "<<node.getType()<<" ("<<node.getName()<<')'<<std::endl;
    return false;
}

const Context::cfgparamlist_t* Context::getParam(const std::string& type) const
{
    params_t::const_iterator it=m_params.find(type);
    if(it==m_params.end())
        return 0;
    return &it->second;
}


bool Context::complete()
{
    unsetparams_t& unsetParams=getUnsetParams();
    for(unsetparams_t::iterator it=unsetParams.begin();it!=unsetParams.end();) {
        const cfgparamlist_t* params;
        if(m_parent && it->second.inheritable()) {
            if((params=m_parent->getParam(it->first))) {
                //Have to increment _before_ calling setParam,
                //since setParam may erase current element, thus
                //invalidating current iterator.
                //At the same time I have to increment it _after_
                //I used it to get any data I need
                it++;
                for(cfgparamlist_t::const_iterator it=params->begin();
                    it!=params->end(); it++)
                {
                    setParam(*it);
                }
                continue;
            }
        }
        if(it->second.required()) {
            std::cerr<<"Parameter "<<it->first<<" must be set in context "<<getType()<<" ("<<getName()<<')'<<std::endl;
            return false;
        }
        it++; // see comments above...
    }
    if(!onPreComplete()) {
        std::cerr<<"Error in context setup "<<getType()<<" ("<<getName()<<')'<<std::endl;
        return false;
    }
    for(ctxlist_t::iterator it=m_kids.begin(); it!=m_kids.end(); it++){
        if(!(*it)->complete()) {
            std::cerr<<"Error in context setup completion "<<(*it)->getType()
                <<" ("<<(*it)->getName()<<')'<<std::endl;
            return false;
        }
    }
    return onPostComplete();
}

bool Context::setString(const ConfigNode& node, std::string& dest)
{
    util::param_t::const_iterator value=node.getAttrs().find("value");
    if(value==node.getAttrs().end()) {
        std::cerr<<"No value specified"<<std::endl;
        return false;
    }
    dest=value->second;
    return true;
}

}
}