ConfigFile.h

#ifndef _ZAKCONFIGFILE_H_
#define _ZAKCONFIGFILE_H_

#include <fstream>
#include <string.h>
#include <stdlib.h>
//#include <iostream>
#include "defines.h"

using namespace std;

#define ZAK_CFG_MAX_CHARACTERS                  256

#define ZAK_CFG_START_SECTION_NAME              '['
#define ZAK_CFG_END_SECTION_NAME                ']'
#define ZAK_CFG_EQUAL                                   '='
#define ZAK_CFG_COMMENT                                 ';'
#define ZAK_CFG_STRING                                  '"'


namespace zak {

class ZAKENGINE_API ConfigFile : protected SupportScriptReferences
{
public:

        bool Load(const char* szFilename);

        int ReadInteger(const char *pszSection,
                                        const char *pszOption,
                                        int iDefaultValue);

        long ReadLong (const char *pszSection,
                                        const char *pszOption,
                                        long lDefaultValue);

        DWORD ReadDWord (const char *pszSection,
                                        const char *pszOption,
                                        DWORD DefaultValue);

        bool ReadBoolean(const char *pszSection,
                                                const char *pszOption,
                                                bool bDefaultValue);

        float ReadFloat(const char *pszSection,
                                        const char *pszOption,
                                        float fDefaultValue);

        char *ReadString(const char *pszSection,
                                        const char *pszOption,
                                                const char *pszDefaultValue);

        ConfigFile();

        ConfigFile(const char *Filename);

        ~ConfigFile();

private:
        static bool RegisterConfigFile(char *className=NULL);

        static void Constructor(ConfigFile *parser){
                new(parser) ConfigFile();
        }
        static void Destructor(ConfigFile *parser){
                parser->~ConfigFile();
        }


        bool Load(string &szFilename) {
                return Load(szFilename.c_str());
        }

        int ReadInteger(string &pszSection,
                                        string &pszOption,
                                        int iDefaultValue) {
                return ReadInteger(pszSection.c_str(), pszOption.c_str(), iDefaultValue);
        }
        long ReadLong (string &pszSection,
                                        string &pszOption,
                                        long lDefaultValue) {
                return ReadLong(pszSection.c_str(), pszOption.c_str(), lDefaultValue);
        }
        DWORD ReadDWord (string &pszSection,
                                        string &pszOption,
                                        DWORD DefaultValue) {
                return ReadDWord(pszSection.c_str(), pszOption.c_str(), DefaultValue);
        }
        bool ReadBoolean(string &pszSection,
                                                string &pszOption,
                                                bool bDefaultValue) {
                return ReadBoolean(pszSection.c_str(), pszOption.c_str(), bDefaultValue);
        }
        float ReadFloat(string &pszSection,
                                string &pszOption,
                                float fDefaultValue) {
                return ReadFloat(pszSection.c_str(), pszOption.c_str(), fDefaultValue);
        }
        string ReadString(const string &pszSection,
                                       const string &pszOption,
                                                const string &pszDefaultValue) {
                string str = ReadString(pszSection.c_str(), pszOption.c_str(), pszDefaultValue.c_str());
                return str;
        }

        ifstream    _ifs;

        char _szString[ZAK_CFG_MAX_CHARACTERS]; 
        
        // Deletes all the unneeded chars
        void deleteUnneeded(char *szString);

        // Search in file for a specific section
        void searchSection(const char *szSection);

        // Search a specific value in the file
        void searchValue(char *pszString, const char *szOption);

        friend class ScriptMgr;
};

} // end namespace 

#endif // _CONFIGFILE_H_

---