Config Class

    //Config.h  
    #pragma once  
      
    #include   
    #include 

 
   

 // Config.cpp  
      
    #include "Config.h"  
      
    using namespace std;  
      
      
    Config::Config( string filename, string delimiter,  
                   string comment )  
                   : m_Delimiter(delimiter), m_Comment(comment)  
    {  
        // Construct a Config, getting keys and values from given file  
      
        std::ifstream in( filename.c_str() );  
      
        if( !in ) throw File_not_found( filename );   
      
        in >> (*this);  
    }  
      
      
    Config::Config()  
    : m_Delimiter( string(1,'=') ), m_Comment( string(1,'#') )  
    {  
        // Construct a Config without a file; empty  
    }  
      
      
      
    bool Config::KeyExists( const string& key ) const  
    {  
        // Indicate whether key is found  
        mapci p = m_Contents.find( key );  
        return ( p != m_Contents.end() );  
    }  
      
      
    /* static */  
    void Config::Trim( string& inout_s )  
    {  
        // Remove leading and trailing whitespace  
        static const char whitespace[] = " 
\t\v\r\f";  
        inout_s.erase( 0, inout_s.find_first_not_of(whitespace) );  
        inout_s.erase( inout_s.find_last_not_of(whitespace) + 1U );  
    }  
      
      
    std::ostream& operator<first << " " << cf.m_Delimiter << " ";  
            os << p->second << std::endl;  
        }  
        return os;  
    }  
      
    void Config::Remove( const string& key )  
    {  
        // Remove key and its value  
        m_Contents.erase( m_Contents.find( key ) );  
        return;  
    }  
      
    std::istream& operator>>( std::istream& is, Config& cf )  
    {  
        // Load a Config from is  
        // Read in keys and values, keeping internal whitespace  
        typedef string::size_type pos;  
        const string& delim  = cf.m_Delimiter;  // separator  
        const string& comm   = cf.m_Comment;    // comment  
        const pos skip = delim.length();        // length of separator  
      
        string nextline = "";  // might need to read ahead to see where value ends 
      
        while( is || nextline.length() > 0 )  
        {  
            // Read an entire line at a time  
            string line;  
            if( nextline.length() > 0 )  
            {  
                line = nextline;  // we read ahead; use it now  
                nextline = "";  
            }  
            else  
            {  
                std::getline( is, line );  
            }  
      
            // Ignore comments  
            line = line.substr( 0, line.find(comm) );  
      
            // Parse the line if it contains a delimiter  
            pos delimPos = line.find( delim );  
            if( delimPos < string::npos )  
            {  
                // Extract the key  
                string key = line.substr( 0, delimPos );  
                line.replace( 0, delimPos+skip, "" );  
      
                // See if value continues on the next line  
                // Stop at blank line, next line with a key, end of stream,  
                // or end of file sentry  
                bool terminate = false;  
                while( !terminate && is )  
                {  
                    std::getline( is, nextline );  
                    terminate = true;  
      
                    string nlcopy = nextline;  
                    Config::Trim(nlcopy);  
                    if( nlcopy == "" ) continue;  
      
                    nextline = nextline.substr( 0, nextline.find(comm) );  
                    if( nextline.find(delim) != string::npos )  
                        continue;  
      
                    nlcopy = nextline;  
                    Config::Trim(nlcopy);  
                    if( nlcopy != "" ) line += "
";  
                    line += nextline;  
                    terminate = false;  
                }  
      
                // Store key and value  
                Config::Trim(key);  
                Config::Trim(line);  
                cf.m_Contents[key] = line;  // overwrites if key is repeated  
            }  
        }  
      
        return is;  
    }  
    bool Config::FileExist(std::string filename)  
    {  
        bool exist= false;  
        std::ifstream in( filename.c_str() );  
        if( in )   
            exist = true;  
        return exist;  
    }  
      
    void Config::ReadFile( string filename, string delimiter,  
                          string comment )  
    {  
        m_Delimiter = delimiter;  
        m_Comment = comment;  
        std::ifstream in( filename.c_str() );  
      
        if( !in ) throw File_not_found( filename );   
      
        in >> (*this);  
    }