C++ ini解析器

　　在gitee上找到的一个很好用的ini文件解析器，纯C++代码，移植方便。

　　项目地址：https://gitee.com/sollyu/IniParser

　　稍微修改了下，去掉了Windows平台相关定义，改了下类名称。

　　头文件：

#ifndef INIPARSER_H
#define INIPARSER_H


#include <map>
#include <string>
#include <string.h>

class IniDoc
{
public:
    struct IgnoreCaseLT
    {
        bool operator()(const std::string& lhs, const std::string& rhs) const
        {
            return strcasecmp(lhs.c_str(), rhs.c_str()) < 0;
        }
    };

public:
    typedef std::map<std::string, std::string, IgnoreCaseLT> KeyMap;
    typedef std::map<std::string, KeyMap,      IgnoreCaseLT> SectionMap;
    typedef KeyMap::iterator     KeyIterator;
    typedef SectionMap::iterator SectionIterator;

public:
    // 默认的构造函数和析构函数
    IniDoc();
    ~IniDoc();

    // 构造函数 - 加载文件
    IniDoc(const std::string& file_name);

    // 加载一个ini文件, 如果之前的文件被修改, 那么之前的ini文件将会被保持。
    bool load(const std::string& file_name);

    // 从字符串中作为ini文件加载
    bool loadString(const std::string& str);

    // 保持到加载ini位置
    bool save();

    // 另存为一个和加载路径不一样的文件中
    bool saveAs(const std::string& file_name);

    // 返回ini是否被修改, 或者他最后一次操作是保存
    bool isModified() const { return m_modified; }

public:    // high level member function.

    // 下面的成员函数是从Section中获得一些值
    long getInteger(const std::string& section, const std::string& key, long def_val);
    float getFloat(const std::string& section, const std::string& key, float def_val);
    long getStruct(const std::string& section, const std::string& key, void* buffer, long size);
    long getString(const std::string&  section, const std::string& key, const std::string& def_val, std::string& buffer);
    const std::string getString(const std::string&  section, const std::string& key, const std::string& def_val);

    void setInteger(const std::string& section, const std::string& key, long value);
    void setFloat(const std::string& section, const std::string& key, float value);
    void setStruct(const std::string& section, const std::string& key, const void* buffer, long size);
    void setString(const std::string& section, const std::string& key, const std::string& value);

public:
    bool delSection( const std::string& section );
    bool delKey( const std::string& section, const std::string& key );

public:
    // 返回一个section的map键值对
    const KeyMap& getSection(const std::string& section) const;

    // 返回整个ini的Sections
    const SectionMap& getIni() const { return m_map; }

private:
    void saveBeforeLoad();
    const char* key_value(const std::string& section, const std::string& key);

private:
    // 禁止复制构造函数和赋值操作符。
    IniDoc(const IniDoc& copy);
    IniDoc& operator=(const IniDoc& rhs);

private:
    static const KeyMap ms_emptySection;
    static const char   left_tag       ;
    static const char   right_tag      ;
    static const char   equal          ;
    static const char   cr             ;
    static const char   new_line       ;
    static const char*  empty_str      ;
    static const int    BUFFER_LEN     ;

    SectionMap  m_map;
    std::string m_file_name;
    bool        m_modified;
};

#endif // INIPARSER_H

　　源文件：

#include "IniDoc.h"

#include <fstream>
#include <strstream>

using namespace std;

const char  IniDoc::left_tag   = '[' ;
const char  IniDoc::right_tag  = ']' ;
const char  IniDoc::equal      = '=' ;
const char  IniDoc::cr         = '
';
const char  IniDoc::new_line   = '
';
const char* IniDoc::empty_str  = ""  ;
const int   IniDoc::BUFFER_LEN = 255 ;

const IniDoc::KeyMap IniDoc::ms_emptySection;

IniDoc::IniDoc() : m_modified(false)
{

}

IniDoc::IniDoc(const std::string& file_name) : m_modified(false)
{
    load(file_name);
}

IniDoc::~IniDoc()
{
    if(m_modified)
        save();
}

void IniDoc::saveBeforeLoad()
{
    if(m_modified)
        save();

    m_file_name.resize(0);

    m_map.clear();

    m_modified = false;
}

const char* IniDoc::key_value(const std::string& section, const std::string& key)
{
    SectionIterator itSection = m_map.find(section);
    if(m_map.end() != itSection)
    {
        KeyIterator itKey = itSection->second.find(key);
        if(itKey != itSection->second.end())
            return itKey->second.c_str();
    }

    return 0;
}

bool IniDoc::load(const std::string& file_name)
{
    saveBeforeLoad();

    ifstream file(file_name);
    if(!file)
        return false;

    file.seekg(0, ios::end);
    long len = file.tellg();
    if(len < 0)
        return false;


    char* buffer = new char[len + 1];
    if(0 == buffer)
        return false;


    file.seekg(0, ios::beg);
    file.read(buffer, len);

    buffer[len = file.gcount()] = 0;

    loadString(buffer);
    m_file_name = file_name;

    delete[] buffer;

    return true;
}

bool IniDoc::loadString(const std::string& str)
{
    saveBeforeLoad();

    unsigned long length = str.size();

    if (str.size() == 0)
        return false;

    enum status
    {
        after_left_tag,
        after_section_name,
        after_section_name_ws,
        after_key_name,
        after_key_name_ws,
        after_equal,
        start
    };

    string section;                       // 当前 section.
    string key;                           // 当前 key.
    status sta          = start;          // 解析状态.
    const char* p       = str.c_str();    // 当前解析字符串的位置.
    const char* beg     = p;              // 当前元素的开始.
    const char* last_ws = p;              // 最后一个空格字符.

    for(; length; ++p, --length)
    {
        if(new_line == *p)
        {
            if(after_equal == sta)
            {
                if(cr == *(p - 1))
                    --p;

                m_map[section][key] = string(beg, p - beg);

                if(cr == *p)
                    ++p;
            }
            sta = start;
        }
        else
        {
            switch(sta)
            {
            case after_left_tag:
                if(right_tag == *p)
                {
                    sta     = start;
                    section = empty_str; // empty section name.
                }
                else if(!isspace((unsigned char)*p))
                {
                    sta = after_section_name;
                    beg = p;
                }
                break;
            case after_section_name:
                if(right_tag == *p)
                {
                    sta     = start;
                    section = string(beg, p - beg);
                }
                else if(isspace((unsigned char)*p))
                {
                    sta     = after_section_name_ws;
                    last_ws = p;
                }
                break;
            case after_section_name_ws:
                if(right_tag == *p)
                {
                    sta     = start;
                    section = string(beg, last_ws - beg);
                }
                else if(!isspace((unsigned char)*p))
                {
                    sta = after_section_name;
                }
                break;
            case after_key_name:
                if(equal == *p)
                {
                    sta = after_equal;
                    key = string(beg, p - beg);
                    beg = p + 1;
                }
                else if(isspace((unsigned char)*p))
                {
                    sta     = after_key_name_ws;
                    last_ws = p;
                }
                break;
            case after_key_name_ws:
                if(equal == *p)
                {
                    sta = after_equal;
                    key = string(beg, last_ws - beg);
                    beg = p + 1;
                }
                else if(!isspace((unsigned char)*p))
                {
                    sta = after_key_name;
                }
                break;
            case start:
                if(left_tag == *p)
                {
                    sta = after_left_tag;
                }
                else if(equal == *p)
                {
                    key = empty_str;  // an empty key.
                    sta = after_equal;
                    beg = p + 1;
                }
                else if(!isspace((unsigned char)*p))
                {
                    sta = after_key_name;
                    beg = p;
                }
                break;
            }
        }
    }

    if(after_equal == sta)
        m_map[section][key] = string(beg, p - beg);

    return true;
}

bool IniDoc::save()
{
    if(0==m_file_name.c_str() || 0==m_file_name[0])
        return false;    // file name invalid

    ofstream file(m_file_name.c_str());
    if(!file)
        return false;

    for(SectionMap::iterator itApp=m_map.begin(); itApp!=m_map.end(); ++itApp)
    {
        file << left_tag << itApp->first << right_tag << endl;

        for(KeyMap::iterator itKey=itApp->second.begin(); itKey!=itApp->second.end(); ++itKey)
            file << itKey->first << equal << itKey->second << endl;

        file << endl;
    }
    m_modified = false;

    return true;
}

bool IniDoc::saveAs(const std::string& file_name)
{
    string old_file_name = m_file_name;
    m_file_name = file_name;

    if(save())
        return true;

    m_file_name = old_file_name;
    return false;
}

long IniDoc::getInteger(const std::string& section, const std::string& key, long def_val)
{
    istrstream(key_value(section, key)) >> def_val;
    return def_val;
}

float IniDoc::getFloat(const std::string& section, const std::string& key, float def_val)
{
    istrstream(key_value(section, key)) >> def_val;
    return def_val;
}

long IniDoc::getStruct(const std::string& section, const std::string& key_, void* buffer, long size)
{
    std::string key = key_value(section, key_);

    if (key.size() == 0)
        return 0;

    const char* p        = key.c_str();
    char*       dst      = (char*)buffer;
    long        read_len = 0;
    char        value;

    while(*p && read_len<size)
    {
        switch(*p)
        {
        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
            value = *p - '0';
            break;
        case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
            value = *p - 'a' + 10;
            break;
        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
            value = *p - 'A' + 10;
            break;
        default:
            return read_len;
        }


        if(0 == (p - key.c_str())%2)
            *(dst + read_len) = value << 4;
        else
            *(dst + read_len) = (*(dst + read_len) & 0xf0) + value;


        if(0 == (++p - key.c_str())%2)
            ++read_len;
    }

    return read_len;
}

long IniDoc::getString(const std::string& section, const std::string& key_, const std::string& def_val, std::string& dst_str)
{
    std::string key = key_value(section, key_);
    dst_str = key.length() ? key : def_val;
    return dst_str.length();
}

const std::string IniDoc::getString(const std::string& section, const std::string& key_, const std::string& def_val)
{
    std::string key = key_value(section, key_);
    if(key.length() == 0)
        key = def_val;

    return key;
}

void IniDoc::setInteger(const std::string& section, const std::string& key, long value)
{
    char buffer[BUFFER_LEN + 1];
    ostrstream ostr(buffer, BUFFER_LEN);
    ostr << value;
    buffer[ostr.pcount()] = 0;
    setString(section, key, buffer);
}

void IniDoc::setFloat(const std::string& section, const std::string& key, float value)
{
    char buffer[BUFFER_LEN + 1];
    ostrstream ostr(buffer, BUFFER_LEN);
    ostr << value;
    buffer[ostr.pcount()] = 0;
    setString(section, key, buffer);
}

inline char bin2hex(char bin)
{
    return bin<10 ? bin+'0' : bin-10+'A';
}

void IniDoc::setStruct(const std::string& section, const std::string& key, const void* buffer, long size)
{
    char* dst = new char[size*2 + 1];
    if(dst)
    {
        const char* src = (const char*)buffer;
        long i=0;
        for(i=0; i<size; ++i)
        {
            dst[i << 1]       = bin2hex((src[i] >> 4) & 0x0f );
            dst[(i << 1) + 1] = bin2hex(src[i] & 0x0f);
        }

        dst[i << 1] = 0;
        setString(section, key, dst);

        delete[] dst;
    }
}

void IniDoc::setString(const std::string& section, const std::string& key, const std::string& value)
{
    m_map[section][key] = value;
    m_modified = true;
}

bool IniDoc::delSection( const std::string& section )
{
    SectionIterator itSection = m_map.find(section);
    if(m_map.end() != itSection)
    {
        m_map.erase(itSection);
        return true;
    }
    return false;
}

bool IniDoc::delKey( const std::string& section, const std::string& key )
{
    SectionIterator itSection = m_map.find(section);
    if(m_map.end() != itSection)
    {
        KeyIterator itKey = itSection->second.find(key);
        if(itKey != itSection->second.end())
        {
            itSection->second.erase(itKey);
            return true;
        }
    }
    return false;
}

const IniDoc::KeyMap& IniDoc::getSection(const std::string& section) const
{
    SectionMap::const_iterator itApp = m_map.find(section);
    return m_map.end()==itApp ? ms_emptySection : itApp->second;
}