c++ ini parser class

最早ini用win32 api，后来用qt的setting类，或者用ogre的时候cfg读取也很方便，现在重新回到最原始的sdk层次，感觉有必要写一个自己的ini类了。

查看了下ogre的实现，麻烦的很，搞了很多不必要的麻烦工作，不可理解；qt的就更不想看了，移植起来估计会很累。google了一把，找来找去，都不满意，我理想中的ini类，应该就是个.h文件，简洁明了，支持读取section/key/value,load/save就可以了。在codeproject找到了一个CInixxxx的class，初看好像挺简介，然后改了改，最后发现基本不能用，还是重写一个更快些。贴出来，顺便看看转换后的code效果。

 #ifndef __sglib_inifile_h
 #define __sglib_inifile_h


 #include <map>
 #include <string>
 #include <iostream>

 #include <fstream>
 #include <algorithm>
 #include <functional>

 #include <sstream>

 namespace sglib {


 template<typename rtT>
 rtT string_toT (const std::string & value , rtT def = 0){

  rtT ret;
  std::istringstream is(value);

  is >> (rtT)ret ;
  if( is.fail())

   return def;
  return ret;
 };


 class ini_file {
  inline void string_trim(std::string& str, const std::string & chrs_trim = " \t\n\r", int trim_dir = 0){

   size_t start_index = str.find_first_not_of(chrs_trim);

   if (start_index == std::string::npos){

    str.erase();
    return;
   }

   if (trim_dir < 2)
    str = str.substr(start_index, str.size()-start_index);

   if (trim_dir!=1)
    str = str.substr(0, str.find_last_not_of(chrs_trim) + 1);

  }
  inline void string_remove_comment(std::string & s){

   std::basic_string <char>::size_type  idx;
   idx = s.find('#');

   if( idx!= std::string::npos)

    s.erase(idx);           
   idx = s.find(';');

   if( idx!= std::string::npos)

    s.erase(idx);           
  }
  inline void string_simplify (std::string & str){

   string_remove_comment(str);
   string_trim(str);

  }
  //inline void trim_right(std::string& str, const std::string & chrs_trim = " \t\n\r")

  //{
  //    trim(str, chrs_trim, 2);
  //}


  //inline void trim_left(std::string& str, const std::string & chrs_trim = " \t\n\r")
  //{

  //    trim(str, chrs_trim, 1);
  //}
  inline void string_lower(std::string& str)

  {
   std::transform (str.begin(), str.end(), str.begin(), tolower);

  }
  inline void string_upper(std::string& str)

  {
   std::transform (str.begin(), str.end(), str.begin(), toupper);

  }

 protected:
  std::string _file_name;

  std::string _cur_section;
  std::map<std::string, std::string> _content;

  std::map<std::string, std::string> _root;


  void add_record(const std::string & key, const std::string & value){

   if(_cur_section == "")
    _root[key] = value;

   else{
    std::string map_key = _cur_section + ":" + key;

    _content[map_key] = value;
   }

  }
  std::string _get_root_value (const std::string & key, std::string default_value){

   std::map<std::string, std::string>::iterator f;

   f = _root.find(key);
   if(f ==  _root.end())

    return default_value;
   return f->second;

  }

  std::string _get_value (const std::string & section_key, std::string default_value){

   std::map<std::string, std::string>::iterator f;

   f = _content.find(section_key);
   if(f ==  _content.end())

    return default_value;
   return f->second;

  }
  
 public:
  ini_file(void)

   : _file_name(""){
  }
  ini_file(std::string file_name)

   : _file_name(file_name){
  }
  virtual ~ini_file(void){

  }

 public:
  std::string get_value (const std::string & section_key){

   if(section_key.find(':') != std::string::npos)

    return _get_value(section_key, "");
   return _get_root_value(section_key, "");

  }

  std::string get_value (const std::string & section, const std::string & key){

   if(section == "")
    return _get_root_value(key, "");

   std::string map_key = section + ":" + key;

   return _get_value(map_key, "");
  }


  std::string get_value (const std::string & section, const std::string & key, const std::string & default_value){

   if(section == "")
    return _get_root_value(key, default_value);

   std::string map_key = section + ":" + key;

   return _get_value(map_key, default_value);
  }


  int get_int (const std::string & section_key, int def = 0){

   std::string value = get_value (section_key);

   return string_toT<int>(value, def);
  }

  int get_int (const std::string & section, const std::string & key, int def = 0){

   std::string value = get_value (section, key);

   return string_toT<int>(value, def);
  }

  float get_float (const std::string & section_key, float def = 0){

   std::string value = get_value (section_key);

   return string_toT<float>(value, def);
  }

  float get_float (const std::string & section, const std::string & key, float def = 0){

   std::string value = get_value (section, key);

   return string_toT<float>(value, def);
  }

  bool get_bool (std::string section_key, bool def = false){

   std::string value = get_value (section_key);

   string_lower(value);
   if(value == "true")

    return true;
   if(value == "false")

    return false;
   return def;
  }

  bool get_bool (const std::string & section, const std::string & key, bool def = false){

   std::string value = get_value (section, key);

   string_lower(value);
   if(value == "true")

    return true;
   if(value == "false")

    return false;
   return def;
  }


  // set 
  void set_value(std::string key, std::string value){

   _root[key] = value;
  }
  void set_value(std::string section, std::string key, std::string value){

   if(section == "")
    _root[key] = value;

   else {
    std::string map_key = section + ":" + key;

    _content[map_key] = value;
   }
  }


 public: 
  bool load (){

   return load(_file_name);
  }
  bool save (){

   return save(_file_name);
  }

  bool load (std::string file_name){

   std::string s;    
   std::string key;    

   std::string value;    
   std::string cur_section; 

   std::basic_string <char>::size_type idx;
   

   _file_name = file_name;
   std::ifstream file(file_name.c_str());      

   if (!file.is_open())
    return false;         


   _root.clear();
   _content.clear(); 

   _cur_section = "";

   while(!std::getline(file, s).eof()) { 

    string_simplify(s);
    if(s.empty())

     continue;
    if(s[0] == '[') {

     idx = s.find(']');
     if( idx != std::string::npos){

      _cur_section = s.substr(1, idx-1);

      string_simplify(_cur_section);
     }
     continue;

    }
    idx = s.find('=');  

    if(idx != std::string::npos){

     key   = s.substr (0, idx);

     string_simplify(key);

     value = s.substr (idx+1);

     string_simplify(value);

     add_record(key, value);

    }
   }
   file.close();  

   return true;
  }
  
  bool save(const std::string & file_name) {

   std::ofstream of(file_name.c_str()); 

   if (!of.is_open())
    return false;       

   std::for_each(_root.begin(), _root.end(), save_item(of));

   std::for_each(_content.begin(), _content.end(), save_item(of));

   of.close();         
   return true;
  };

 private:
  struct save_item {
   std::ofstream & _of;

   std::string _section;
   save_item(std::ofstream &of): _of(of), _section(""){}


   void operator () (const std::pair<std::string, std::string> & a) {

    std::string key = a.first;
    std::string sec = a.first;

    std::basic_string <char>::size_type idx = sec.find(':');

    
    if( idx != std::string::npos){

     key.erase(0, idx+1);
     sec.erase(idx);

     if(_section != sec ){
      _section = sec;

      if(_section != "")
       _of << std::endl << "[" << _section << "]" << std::endl;

     }
    }
    _of << key << " = " << a.second << std::endl;

   }
  };
 };

 } // sglib

 #endif