/home/vlg/develop/libASSA/libassa/assa/IniFile.cpp

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
// $Id: IniFile.cpp,v 1.7 2005/08/19 03:18:24 vlg Exp $
//------------------------------------------------------------------------------
//                             IniFile.cpp
//------------------------------------------------------------------------------
//  Copyright (C) 2003,2004  Vladislav Grinchenko <vlg@users.sourceforge.net>
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//
//  Date: Sat Sep  6 00:17:52 EDT 2003
//------------------------------------------------------------------------------

#include <assa/Assure.h>
#include <assa/IniFile.h>
#include <assa/CommonUtils.h>
using namespace ASSA;

IniFile::
IniFile (const string& fname_) 
    :
    m_fname (fname_),
    m_section_pttrn ("\\[[a-zA-Z0-9]+.*] *$"),
    m_tuple_pttrn ("^[ \t]*[a-zA-Z0-9]+.* *= *.*"),
    m_comment_pttrn ("^#.*$")
{
    trace_with_mask ("IniFile::IniFile", INIFILE);
}
    
IniFile::
~IniFile ()
{
    trace_with_mask ("IniFile::~IniFile", INIFILE);
    m_config.clear ();
}

int 
IniFile::
load ()
{
    trace_with_mask ("IniFile::load", INIFILE);
    
    const int size = 1024;
    char inbuf [size];

    string line;
    string name;
    string value;
    int ret = -1;

    m_stream.open (m_fname.c_str (), std::ios::in);
    if (!m_stream) {
        goto done;
    }

    while (m_stream) {
        m_stream.getline (inbuf, size, '\n');
        DL((INIFILE,"Input: \"%s\"\n", inbuf));

        if (::strlen (inbuf) == 0 || m_comment_pttrn.match (inbuf) == 0) {
            continue;
        }
        line = inbuf;
        if (m_section_pttrn.match (inbuf) == 0) {
            if (trim_section_name (line) < 0) {
                goto done;
            }
            m_config.push_back (sect_type (line, std::list<tuple_type> ()));
        }
        else if (m_tuple_pttrn.match (inbuf) == 0) {
            if (Utils::split_pair (line, '=', name, value) < 0) {
                goto done;
            }
            Utils::trim_sides (name);
            Utils::trim_sides (value);
            m_config.back ().second.push_back (tuple_type (name, value));
        }
        else {
            goto done;
        }
    }
    ret = 0;

 done:
    if (ret < 0) {
        DL((INIFILE, "Parse error: illegal syntax!\n"));
    }
    m_stream.clear ();
    m_stream.close ();
    return ret;
}

int 
IniFile::
sync (const string& fname_)
{
    trace_with_mask ("IniFile::sync(fname)", INIFILE);

    ::unlink (fname_.c_str ());
    m_stream.open (fname_.c_str (), std::ios::app | std::ios::out);
    if (!m_stream) {
        EL((INIFILE,"Failed to open(\"%s\", app|out)\n", fname_.c_str ()));
        return -1;
    }
    const_config_iterator i = m_config.begin ();
    const_tuple_iterator j;

    while (i != m_config.end ()) {
        m_stream << "[" << (*i).first << "]\n";
        j = (*i).second.begin ();

        while (j != (*i).second.end ()) {
            m_stream << (*j).first << "=" << (*j).second << "\n";
            j++;
        }
        m_stream << "\n";
        i++;
    }
    m_stream.clear ();
    m_stream.close ();
    return 0;
}

void 
IniFile::
dump () const
{
    trace_with_mask ("IniFile::dump", INIFILE);

    const_config_iterator i = m_config.begin ();
    const_tuple_iterator j;

    DL((INIFILE,"============= Start =================\n"));

    while (i != m_config.end ()) {
        DL((INIFILE, "[%s]\n", (*i).first.c_str ()));
        j = (*i).second.begin ();
        while (j != (*i).second.end ()) {
            DL((INIFILE, "  %s=\%s\n",
                (*j).first.c_str (), (*j).second.c_str ()));
            j++;
        }
        i++;
    }
    DL((INIFILE,"============== End  =================\n"));
}

string
IniFile::
get_value (const string& section_, const string& name_) const
{
    const_config_iterator i = m_config.begin ();
    const_tuple_iterator j;
    string ret ("");

    while (i != m_config.end ()) {
        if ((*i).first == section_) {
            j = (*i).second.begin ();
            while (j != (*i).second.end ()) {
                if ((*j).first == name_) {
                    ret = (*j).second;
                    break;
                }
                j++;
            }
        }
        i++;
    }
    return ret;
}

void
IniFile::
add_section (const string& section_)
{
    const_config_iterator i = find_section (section_);
    if (i == m_config.end ()) {
        m_config.push_back (sect_type (section_, std::list<tuple_type> ()));
    }
}

IniFile::config_iterator 
IniFile::
find_section (const string& section_)
{
    config_iterator i = m_config.begin ();

    while (i != m_config.end ()) {
        if ((*i).first == section_) {
            return (i);
        }
        i++;
    }
    return m_config.end ();
}

IniFile::const_config_iterator 
IniFile::
find_section (const string& section_) const
{
    const_config_iterator i = m_config.begin ();

    while (i != m_config.end ()) {
        if ((*i).first == section_) {
            return (i);
        }
        i++;
    }
    return m_config.end ();
}

int
IniFile::
set_pair (const string& section_, const tuple_type& newkey_)
{
    trace_with_mask ("IniFile::set_pair", INIFILE);

    config_iterator i = find_section (section_);
    if (i == sect_end ()) {
        DL((INIFILE,"Section [%s] is not found!\n", section_.c_str ()));
        return -1;
    }
    tuple_iterator j = (*i).second.begin ();
    while (j != (*i).second.end ()) {
        if ((*j).first == newkey_.first) {
            (*j).second = newkey_.second;
            return 0;
        }
        j++;
    }
    (*i).second.push_back (newkey_);
    return 0;
}

int
IniFile::
drop_section (const string& section_)
{
    trace_with_mask ("IniFile::drop_section", INIFILE);

    config_iterator i = find_section (section_);
    if (i == sect_end ()) {
        DL((INIFILE,"Section [%s] is not found!\n", section_.c_str ()));
        return -1;
    }
    m_config.erase (i);
    return 0;
}

int
IniFile::
drop_pair (const string& section_, const string& name_)
{
    trace_with_mask ("IniFile::drop_pair", INIFILE);

    config_iterator i = find_section (section_);
    if (i == sect_end ()) {
        DL((INIFILE,"Section [%s] is not found!\n", section_.c_str ()));
        return -1;
    }

    tuple_iterator j = (*i).second.begin ();
    while (j != (*i).second.end ()) {
        if ((*j).first == name_) {
            (*i).second.erase (j);
            return 0;
        }
        j++;
    }
    return -1;
}

---