IniFile.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
#include <windows.h>    // dcl/Thread.h
#endif
 
#include <stdlib.h>     // ListT.h malloc, free, realloc
#include <string.h>     // ListT.h memset, memmove
 
#include <dcl/Object.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Numeric.h>
#include <dcl/File.h>
#include <dcl/FileInputStream.h>
#include <dcl/FileOutputStream.h>
#include <dcl/InputStreamReader.h>
#include <dcl/BufferedReader.h>
#include <dcl/OutputStreamWriter.h>
#include <dcl/ListT.h>
#include <dcl/IniFile.h>
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/IniFile.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
enum IniLineType
{
    ltSectionName,
    ltComment,
    ltEntry
};
 
struct IniLine
{
    IniLineType  __type;
    String      __name;
    String      __strValue;
 
    IniLine()
    {
    }
 
    IniLine(IniLineType type, const String& str)
    {
        __type = type;
        __name = str;
    }
    IniLine(const String& strKey, const String& strValue)
    {
        __type = ltEntry;
        __name = strKey;
        __strValue = strValue;
    }
    String toString() const
    {
        String str;
        switch (__type) {
            case ltSectionName :
                str = L"[" + __name + L"]";
                break;
            case ltEntry :
                str = __name + L"=" + __strValue;
                break;
            default :
                str = __name;
        }
        return str;
    }
};
 
typedef List<IniLine> IniLineList;
 
IMPLEMENT_CLASSINFO(IniFile, Object)
 
String IniFile::toString() const
{
    return __name;
}
 
#ifdef __DCL_DEBUG
void IniFile::dump(Writer& out) const
{
    Object::dump(out);
    out << L"fileName: " << __name << L"\n";
    if (__handle) {
        const IniLineList* lines = (const IniLineList*)__handle;
        for(IniLineList::ConstIterator it = lines->begin(); 
            it != lines->end(); it++
        ) {
            out << (*it).toString() << L"\n";
        }
    }
}
 
#endif
 
IniFile::IniFile()
{
    __handle = NULL;
    __modified = false;
}
 
IniFile::IniFile(const String& strFileName)
    __DCL_THROWS1(IOException*)
{
    __handle = NULL;
    __modified = false;
 
    __DCL_ASSERT(!strFileName.isEmpty());
 
    IniLineList* lines = new IniLineList;
    __handle = lines;
 
    BufferedReader in(
        new InputStreamReader(
            new FileInputStream(strFileName)
        )
    );
    String s;
    while(in.readLine(s)) {
        s = s.trim();
 
        if (s.isEmpty())
            lines->addTail(IniLine(ltComment, String()));
        else if (s[(size_t)0] == L';' || s[(size_t)0] == L'#') {
            lines->addTail(IniLine(ltComment, s));
        }
        else if (s[(size_t)0] == L'[') {
            // section name
            s = s.trim(L"[]\t ");
            lines->addTail(IniLine(ltSectionName, s));
        }
        else {
            // key=value
            size_t pos = s.indexOf(L'=');
            if (pos != (size_t)-1) {
                String name = s.left(pos).trim();
                String value = s.right(s.length() - pos - 1).trim();
                lines->addTail(IniLine(name, value));
            }
            else {
                // invalid line value. ignore
            }
        }
    }
}
 
IniFile::~IniFile()
{
    if (__handle) {
        try {
            close();
        }
        catch (IOException* e) {
            __DCL_TRACE1(L"%ls\n", e->toString().data());
            e->destroy();
        }
    }
}
 
void IniFile::close()
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(__handle != NULL);
 
    if (__handle != NULL) {
        IniLineList* lines = (IniLineList*)__handle;
        __handle = NULL;
        Exception* e = NULL;
        if (__modified) {
            __modified = false;
            try {
                OutputStreamWriter out(
                    new FileOutputStream(__name, true)
                );
                for (IniLineList::Iterator it = lines->begin();
                    it != lines->end(); it++) {
                    out << (*it).toString() << endl;
                }
            }
            catch (Exception* _e) {
                e = _e;
            }
        }
        delete lines;
        if (e) {
            throw e;
        }
    }
}
 
/*
#ifdef __DCL_DEBUG
void IniFile::dump(FILE* fp)
{
    if (__handle) {
        IniLineList* lines = (IniLineList*)__handle;
        for(IniLineList::Iterator it = lines->begin();
            it != lines->end(); it++
        ) {
            fprintf(fp, "%s\n", (*it).line().cstr());
        }
    }
}
#endif
*/
 
String IniFile::getString(
    const String& strSection,
    const String& strEntry, 
    const wchar_t* pszDefault   // = NULL
) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!strSection.isEmpty());
    __DCL_ASSERT(!strEntry.isEmpty());
 
    String strResult = __getValue(strSection, strEntry);
    if (strResult.isEmpty() && pszDefault != NULL)
        strResult = pszDefault;
 
    return strResult;
}
 
int IniFile::getInteger(
    const String& strSection,
    const String& strEntry, 
    int nDefault
) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!strSection.isEmpty());
    __DCL_ASSERT(!strEntry.isEmpty());
 
    String strResult = __getValue(strSection, strEntry);
    if (!strResult.isEmpty()) {
        try {
            nDefault = Integer::parse(strResult, 10);
        }
        catch (NumericConvertException* e) {
            throw (new IOException(__name, e));
        }
    }
    return nDefault;
}
 
void IniFile::setValue(
    const String& strSection,
    const String& strEntry, 
    const String& strValue
) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!strSection.isEmpty());
    __DCL_ASSERT(!strEntry.isEmpty());
 
    __setValue(strSection, strEntry, strValue);
}
 
void IniFile::setValue(
    const String& strSection,
    const String& strEntry, 
    int nValue
) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!strSection.isEmpty());
    __DCL_ASSERT(!strEntry.isEmpty());
 
    __setValue(strSection, strEntry, Integer::toString(nValue, 10));
}
 
String IniFile::__getValue(
    const String& strSection,
    const String& strEntry
)
{
    __DCL_ASSERT(__handle != NULL);
 
    String strResult;
    if (__handle) {
        IniLineList* lines = (IniLineList*)__handle;
        IniLineList::Iterator it = lines->begin();
        for(; it != lines->end(); it++) {
            if (((*it).__type == ltSectionName)
                && ((*it).__name.compareNoCase(strSection) == 0)
            ) {
                // found section
                it++;
                for( ; (it != lines->end()) && ((*it).__type != ltSectionName);
                     it++
                ) {
                    if (((*it).__type == ltEntry)
                        && ((*it).__name.compareNoCase(strEntry) == 0)
                    ) {
                        strResult = (*it).__strValue;
                        break;
                    }
                }
                break;
            }
        }
    }
 
    return strResult;
}
 
void IniFile::__setValue(
    const String& strSection,
    const String& strEntry,
    const String& strValue
)
{
    __DCL_ASSERT(__handle != NULL);
    __modified = true;
 
    IniLineList* lines = (IniLineList*)__handle;
    for(IniLineList::Iterator it = lines->begin();
        it != lines->end(); it++
    ) {
        if (((*it).__type == ltSectionName)
            && ((*it).__name.compareNoCase(strSection) == 0)
        ) {
            // found!
            it++;
            for( ; (it != lines->end()) && ((*it).__type != ltSectionName);
                it++
            ) {
                if (((*it).__type == ltEntry) 
                    && ((*it).__name.compareNoCase(strEntry) == 0)
                ) {
                    // strEntry 가 있다. 값을 교체한다.
                    (*it).__strValue = strValue;
                    return;
                }
            }
            lines->insert(it, IniLine(strEntry, strValue));
        }
        else {
            // 해당하는 섹션이 없다.
            // 섹션을 추가하고 엔트리를 추가한다.
            lines->addTail(IniLine(ltSectionName, strSection));
            lines->addTail(IniLine(strEntry, strValue));
        }
    }
}
 
#ifdef __WINNT__
 
IMPLEMENT_CLASSINFO(RegIniFile, IniFile)
 
RegIniFile::RegIniFile(HKEY hParentKey, const String& strKey)
    __DCL_THROWS1(IOException*)
    : __reg(hParentKey)
{
    __DCL_ASSERT(!strKey.isEmpty());
 
    __reg.create(strKey, KEY_ALL_ACCESS);
    __handle = &__reg;
    IniFile::__name = strKey;
}
 
void RegIniFile::close()
    __DCL_THROWS1(IOException*)
{
    __handle = NULL;
    __reg.close();
}
 
String RegIniFile::getString(
    const String& strSection,
    const String& strEntry, 
    const wchar_t* pszDefault   // = NULL
) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!strSection.isEmpty());
    __DCL_ASSERT(!strEntry.isEmpty());
 
    String strResult;
    try {
        Registry section(__reg.key(), strSection, KEY_READ);
        strResult = section.getString(strEntry);
    }
    catch (IOException* e) {
        __DCL_TRACE1(L"%ls\n", e->toString().data());
        e->destroy();
 
        if (pszDefault)
            strResult = pszDefault;
    }
 
    return strResult;
}
 
int RegIniFile::getInteger(
    const String& strSection,
    const String& strEntry, 
    int nDefault
) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!strSection.isEmpty());
    __DCL_ASSERT(!strEntry.isEmpty());
 
    int nResult;
    try {
        Registry section(__reg.key(), strSection, KEY_READ);
        nResult = section.getInteger(strEntry);
    }
    catch (IOException* e) {
        __DCL_TRACE1(L"%ls\n", e->toString().data());
        e->destroy();
        nResult = nDefault;
    }
 
    return nResult;
}
 
void RegIniFile::setValue(
    const String& strSection,
    const String& strEntry, 
    const String& strValue
) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!strSection.isEmpty());
    __DCL_ASSERT(!strEntry.isEmpty());
 
    Registry section(__reg.key());
    section.create(strSection);
    section.setValue(strEntry, strValue);
}
 
void RegIniFile::setValue(
    const String& strSection,
    const String& strEntry, 
    int nValue
) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!strSection.isEmpty());
    __DCL_ASSERT(!strEntry.isEmpty());
 
    Registry section(__reg.key());
    section.create(strSection);
    section.setValue(strEntry, nValue);
}
 
#endif  // __WINNT__
 
__DCL_END_NAMESPACE