IniFile.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#if __DCL_WINDOWS
#include <windows.h>    // for dcl/Thread.h
#endif
 
#include <stdlib.h>     // for ListT.h malloc, free, realloc
#include <string.h>     // for 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  m_type;
    String      m_strName;
    String      m_strValue;
 
    IniLine()
    {
    }
 
    IniLine(IniLineType type, const String& str)
    {
        m_type = type;
        m_strName = str;
    }
    IniLine(const String& strKey, const String& strValue)
    {
        m_type = ltEntry;
        m_strName = strKey;
        m_strValue = strValue;
    }
    String toString() const
    {
        String str;
        switch (m_type)
        {
        case ltSectionName :
            str = L"[" + m_strName + L"]";
            break;
        case ltEntry :
            str = m_strName + L"=" + m_strValue;
            break;
        default :
            str = m_strName;
        }
        return str;
    }
};
 
typedef List<IniLine> IniLineList;
 
IMPLEMENT_CLASSINFO(IniFile, Object)
 
String IniFile::toString() const
{
    return m_strName;
}
 
#if __DCL_DEBUG
void IniFile::dump(Writer& out) const
{
    Object::dump(out);
    out << L"fileName: " << m_strName << L"\n";
    if (m_handle)
    {
        const IniLineList* pLines = (const IniLineList*)m_handle;
        for(IniLineList::ConstIterator it = pLines->begin(); 
            it != pLines->end(); it++)
        {
            out << (*it).toString() << L"\n";
        }
    }
}
 
#endif
 
IniFile::IniFile()
{
    m_handle = NULL;
    m_bModified = false;
}
 
IniFile::IniFile(const String& strFileName)
        __DCL_THROWS1(IOException*)
{
    m_handle = NULL;
    m_bModified = false;
 
    __DCL_ASSERT(!strFileName.isEmpty());
 
    IniLineList* pLines = new IniLineList;
    m_handle = pLines;
 
    BufferedReader in(
        new InputStreamReader(
            new FileInputStream(strFileName)
            )
        );
    String s;
    while(in.readLine(s))
    {
        s = s.trim();
 
        if (s.isEmpty())
            pLines->addTail(IniLine(ltComment, String()));
        else if (s[(size_t)0] == L';' || s[(size_t)0] == L'#')
        {
            pLines->addTail(IniLine(ltComment, s));
        }
        else if (s[(size_t)0] == L'[')
        {
            // section name
            s = s.trim(L"[]\t ");
            pLines->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();
                pLines->addTail(IniLine(name, value));
            }
            else
            {
                // invalid line value. ignore
            }
        }
    }
}
 
IniFile::~IniFile()
{
    if (m_handle)
    {
        try
        {
            close();
        }
        catch (IOException* e)
        {
            __DCL_TRACE1(L"%ls\n", e->toString().data());
            e->destroy();
        }
    }
}
 
 
void IniFile::close()
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(m_handle != NULL);
 
    if (m_handle != NULL) {
        IniLineList* pLines = (IniLineList*)m_handle;
        m_handle = NULL;
        Exception* e = NULL;
        if (m_bModified) {
            m_bModified = false;
            try {
                OutputStreamWriter out(
                    new FileOutputStream(m_strName, true)
                );
                for (IniLineList::Iterator it = pLines->begin();
                    it != pLines->end(); it++) {
                    out << (*it).toString() << endl;
                }
            }
            catch (Exception* _e) {
                e = _e;
            }
        }
        delete pLines;
        if (e) {
            throw e;
        }
    }
}
 
/*
#if __DCL_DEBUG
void IniFile::dump(FILE* fp)
{
    if (m_handle)
    {
        IniLineList* pLines = (IniLineList*)m_handle;
        for(IniLineList::Iterator it = pLines->begin(); it != pLines->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(m_strName, 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(m_handle != NULL);
 
    String strResult;
    if (m_handle)
    {
        IniLineList* pLines = (IniLineList*)m_handle;
        IniLineList::Iterator it = pLines->begin();
        for(; it != pLines->end(); it++)
        {
            if (((*it).m_type == ltSectionName)
                && ((*it).m_strName.compareNoCase(strSection) == 0))
            {
                // found section
                it++;
                for( ; (it != pLines->end()) && ((*it).m_type != ltSectionName); it++)
                {
                    if (((*it).m_type == ltEntry)
                        && ((*it).m_strName.compareNoCase(strEntry) == 0))
                    {
                        strResult = (*it).m_strValue;
                        break;
                    }
                }
                break;
            }
        }
    }
 
    return strResult;
}
 
void IniFile::__setValue(
                const String& strSection,
                const String& strEntry,
                const String& strValue
                )
{
    __DCL_ASSERT(m_handle != NULL);
    m_bModified = true;
 
    IniLineList* pLines = (IniLineList*)m_handle;
    for(IniLineList::Iterator it = pLines->begin(); it != pLines->end(); it++)
    {
        if (((*it).m_type == ltSectionName)
            && ((*it).m_strName.compareNoCase(strSection) == 0))
        {
            // found!
            it++;
            for( ; (it != pLines->end()) && ((*it).m_type != ltSectionName); it++)
            {
                if (((*it).m_type == ltEntry) 
                    && ((*it).m_strName.compareNoCase(strEntry) == 0))
                {
                    // strEntry 가 있다. 값을 교체한다.
                    (*it).m_strValue = strValue;
                    return;
                }
            }
            pLines->insert(it, IniLine(strEntry, strValue));
        }
        else
        {
            // 해당하는 섹션이 없다.
            // 섹션을 추가하고 엔트리를 추가한다.
            pLines->addTail(IniLine(ltSectionName, strSection));
            pLines->addTail(IniLine(strEntry, strValue));
        }
    }
}
 
#if __DCL_WINDOWS
 
IMPLEMENT_CLASSINFO(RegIniFile, IniFile)
 
RegIniFile::RegIniFile(HKEY hParentKey, const String& strKey)
        __DCL_THROWS1(IOException*)
    : m_reg(hParentKey)
{
    __DCL_ASSERT(!strKey.isEmpty());
 
    m_reg.create(strKey, KEY_ALL_ACCESS);
    m_handle = &m_reg;
    IniFile::m_strName = strKey;
}
 
void RegIniFile::close()
        __DCL_THROWS1(IOException*)
{
    m_handle = NULL;
    m_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(m_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(m_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(m_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(m_reg.key());
    section.create(strSection);
    section.setValue(strEntry, nValue);
}
 
#endif      // __DCL_WINDOWS
 
__DCL_END_NAMESPACE