Beesnest/DcParameters.cpp

Go to the documentation of this file.

/*
Copyright 2007 Erez Bibi (erezbibi@users.sourceforge.net)
This file is part of Beesnest.

Beesnest 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.

Beesnest 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 Beesnest; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/


/**
 * DcParameters.cpp: Implementation of CdcParameters class.
 * for documentation see the header file.
 */

#include "DcParameters.h"

CdcParameters::t_obj_map CdcParameters::mParam;

bool CdcParameters::ReadParams (const char* file_ext) throw (CdcException)
{
    /* Build a CdcString buffer from the parameters files in the working directory. */
    CdcString buff;
    BuildParamBuffer (buff, CdcFileUtil::GetProgramPath (), file_ext);
    /* Parse the buffer. */
    CdcString name, val, field;
    int start, end;
    bool is_ok = true;
    CdcParameters::CdcNode* cur_node = NULL;
    start = buff.Find ('<');
    /* While you have new <field> */
    while (start != -1)
    {   /* Find the end of field name. */
        end = buff.Find ('>', start);
        if (end == -1)
            throw (CdcExceptionFile ("Bad Parameters file format (Cannot find '>')",
            DC_FILE_EXP));
        /* Get the field name. */
        field = buff.Mid (start + 1, end - start -1);
        /* Ignore attributes. */
        int tmp = field.FindOneOf (" \t\r\n");
        if (tmp > 0)
            field = field.Left (tmp);
        /* Find next field start. */
        start = buff.Find ('<', end);
        /* If this is closing field. */
        if (field[0] == '/')
        {   /* Erase the filed name from the 'name' string. */
            field = field.Mid (1);
            if (cur_node == NULL || field != cur_node->name)
            {
                CdcString temp (
                "Bad Parameters file format - Cannot close field with \"" + field + "\"");
                throw (CdcExceptionFile (temp.GetBuffer (), DC_FILE_EXP));
            }
            name = name.Left (name.GetLength () - field.GetLength ());
            if (name.IsEmpty () == false)
                name = name.Left (name.GetLength () - PARM_SEP_LEN);
            cur_node = cur_node->up;
        }
        else
        {   /* Proper Parameters file will not end here. */
            if (start == -1)
                throw (CdcExceptionFile (
                "Bad Parameters file format (File does not end properly)",
                DC_FILE_EXP));
            /* If this is an opening field name, add the field name into the
            'name' string, read the value, and insert to the map under 'name'. */
            if (name.IsEmpty () == false)
                name += PARM_SEP;
            name += field;
            CdcNode* temp_node = mParam [name];
            if (temp_node == NULL)
            {
                temp_node = new CdcNode (field, cur_node);
                if (temp_node == NULL)
                    throw (CdcExceptionFile ("Out of memory", DC_GENERAL_EXP));
                if (cur_node != NULL)
                    cur_node->oNodes.push_back (temp_node);
            }
            cur_node = temp_node;
            val = buff.Mid (end + 1, start - end -1);
            val.TrimLeft ();
            val.TrimRight ();
            if (val.IsEmpty () == false)    /* Insert to the map if not empty. */
                cur_node->value = val;
            mParam [name] = cur_node; /* maybe just replace... */
        }
    }
    return is_ok;
}


CdcString CdcParameters::GetParam (const CdcString& name)
{
    CdcNode* val = NULL;
    val = mParam [name];
    if (val == NULL)
        return EMPTY_STR;
    return val->value;
}


bool ExtGetParam (const char* name, char* val, int max_len)
{
    CdcString sval = CdcParameters::GetParam (name);
    if (sval.IsEmpty ())
        return false;
    strncpy (val, sval.GetBuffer (), max_len);
    return true;
}


CdcParameters::CdcNode* CdcParameters::GetNodePointer (const char* name)
{
    CdcNode* val = NULL;
    val = mParam [name];
    return val;
}

bool CdcParameters::IsUnder (CdcParameters::CdcNode* node, const CdcString& value,
                             bool partly)
{   /* Base case. */
    if (node == NULL)
        return false;
    /* Compare this node. */
    if (partly)
    {
        if (node->value.Find (value) != -1)
            return true;
    }
    else
    {
        if (node->value == value)
            return true;
    }
    /* Check the child of this node (recursive call). */
    for (CdcParameters::CdcNode::t_node_list::const_iterator
        pos = node->oNodes.begin ();
        pos != node->oNodes.end (); ++pos)

        if (IsUnder ((CdcNode*)(*pos), value, partly) == true)
            return true;
    /* Other base case. */
    return false;
}

bool CdcParameters::IsUnder (const CdcString& name, const CdcString& value,
                             bool partly)
{
    /* Get the starting node and search from it. */
    CdcNode* node = NULL;
    node = mParam [name];
    return IsUnder (node, value, partly);
}


CdcString CdcParameters::GetFullName (const CdcString& name,
                                    const CdcString& start_at)
{
    /* Get the starting node and search from it. */
    CdcNode* node = NULL;
    node = mParam [start_at];
    CdcString temp = FindName (name, node, false);
    if (temp.IsEmpty ()) return temp;
    return start_at + PARM_SEP + temp;
}


CdcString CdcParameters::FindName (const CdcString& name,
                                 CdcParameters::CdcNode* node,
                                 bool append_name)
{   /* Base case. */
    if (node == NULL) return EMPTY_STR;
    if (node->name == name) return name;

    /* Check the child of this node (recursive call). */
    for (CdcParameters::CdcNode::t_node_list::const_iterator
        pos = node->oNodes.begin ();
        pos != node->oNodes.end (); pos++)
    {
        CdcString temp = FindName (name,
            (CdcNode*)(*pos), true);
        if (temp.IsEmpty () == false)
            if (append_name)
                return node->name + PARM_SEP + temp;
            else
                return temp;
    }
    /* Other base case. */
    return EMPTY_STR;
}


int CdcParameters::ToInt (const CdcString& str)
{
    CdcString temp = str;
    return atoi (temp.GetBuffer ());
}

void CdcParameters::BuildParamBuffer (CdcString& buff,
                                      const CdcString& path,
                                      const CdcString& ext)
{
    t_files_vector vect = CdcFileUtil::GetAllFilesInDir
        (path, ext);
    t_files_vector::iterator itr;
    for (itr = vect.begin(); itr != vect.end(); ++itr)
        ReadParamFile (buff, *itr);
}


void CdcParameters::ReadParamFile (CdcString& buff,
                                   const CdcString& file_name)
{
    /* Open the parameters file. */
    ifstream file (file_name.GetBuffer ());
    if (file.is_open () == 0)
        throw (CdcExceptionFile ("Cannot open Parameters file",
            DC_FILE_EXP));

    /* Read the entire file (w/o lines that start with '#' or empty lines) into
    the CdcString buffer. */
    char temp [BUFF_LEN];
    while (file.eof () == 0)
    {
        file.getline (temp, BUFF_LEN, '\n');
        CdcString str = temp;
        str.Trim ();
        int place = str.Find ('#');
        if (place > -1)
            str = str.Left (place);
        if (str.IsEmpty ()) continue;
        buff += str + ' ';
    }
}