Config.h

#ifndef NEO_CONFIG_H
#define NEO_CONFIG_H

namespace neo
{

class Config
{
public:
    virtual ~Config() {}

    bool Write(const tstring& key, const tstring& value)
    {
        return _SetStringImp(key, value);
    }
    bool Read(const tstring& key, tstring& result) const
    {
        return _GetStringImp(key, result);
    }

    template<typename T>
    bool Write(const tstring& key, const T& value)
    {
        return configStructWrite(*this, key, value);
    }

    template<typename T>
    bool Read(const tstring& key, T& result) const
    {
        return configStructRead(*this, key, result);
    }

    void SaveWindowPosition(const tstring& key, HWND window)
    {
        Rect r;
        GetWindowRect(window, &r);
        Write(key, r);
    }

    void RestoreWindowPosition(const tstring& key, HWND window)
    {
        Rect r;
        if(Read(key, r))
            MoveWindow(window, r.left, r.top, r.Width(), r.Height(), TRUE);
    }

    virtual bool Remove(const tstring& key) { return false; }
    virtual bool RemoveEntireConfig() { return false; }
protected:
    virtual bool _SetStringImp(const tstring& key, const tstring& value) = 0;
    virtual bool _GetStringImp(const tstring& key, tstring& result) const = 0;

    static std::string ToUtf8(const tstring& text)
    {
        static_assert(sizeof(TCHAR) == sizeof(wchar_t), "The config classes only work correctly if the project is setup as Unicode");
        int n = WideCharToMultiByte(CP_UTF8, 0, text.c_str(), -1, 0, 0, 0, 0);
        std::string result;
        if(n > 0)
        {
            result.resize(n-1);
            n = WideCharToMultiByte(CP_UTF8, 0, text.c_str(), -1, &result[0], n, 0, 0);
        }
        return result;
    }
    static tstring FromUtf8(const std::string& text)
    {
        static_assert(sizeof(TCHAR) == sizeof(wchar_t), "The config classes only work correctly if the project is setup as Unicode");
        int n = MultiByteToWideChar(CP_UTF8, 0, text.c_str(), -1, 0, 0);
        tstring result;
        if(n > 0)
        {
            result.resize(n-1);
            n = MultiByteToWideChar(CP_UTF8, 0, text.c_str(), -1, &result[0], n);
        }
        return result;
    }
private:
    // Read with generic type and conversion.
    template<class T, class FROMSTRING>
    bool Read(const tstring& key, T& result, FROMSTRING fromString) const
    {
        tstring buffer;
        if(_GetStringImp(key, buffer))
        {
            result = fromString(buffer);
            return true;
        }
        return false;
    }
};

class RegistryConfig : public Config
{
public:
    RegistryConfig();
    RegistryConfig(const tstring& subKey, HKEY topKey = HKEY_CURRENT_USER);
    RegistryConfig(RegistryConfig&& other);
    RegistryConfig& operator=(RegistryConfig&& other);
    ~RegistryConfig();

    bool Open(const tstring& subKey, HKEY topKey = HKEY_CURRENT_USER);

    virtual bool Remove(const tstring& key);
    virtual bool RemoveEntireConfig();
protected:
    bool _SetStringImp(const tstring& key, const tstring& value);
    bool _GetStringImp(const tstring& key, tstring& result) const;
private:
    HKEY openedKey;
};

class iniConfig : public Config
{
public:
    iniConfig();
    iniConfig(const tstring& filepath);
    ~iniConfig();

    bool Open(const tstring& filepath);
    bool Save();

    void SetCurrentSection(const tstring& section);

    virtual bool Remove(const tstring& key);
    virtual bool RemoveEntireConfig();
protected:
    bool _SetStringImp(const tstring& key, const tstring& value);
    bool _GetStringImp(const tstring& key, tstring& result) const;
private:
    tstring Trim(const tstring& text);

    struct iniLine
    {
        iniLine()
        {
            isSection = false;
            isKey = false;
        }
        iniLine(const iniLine& rhs)
            : text1(rhs.text1)
            , text2(rhs.text2)
            , isSection(rhs.isSection)
            , isKey(rhs.isKey)
        {}
        iniLine& operator=(const iniLine& rhs)
        {
            text1 = rhs.text1;
            text2 = rhs.text2;
            isSection = std::move(rhs.isSection);
            isKey = std::move(rhs.isKey);
            return *this;
        }
        iniLine(iniLine&& rhs)
            : text1(std::move(rhs.text1))
            , text2(std::move(rhs.text2))
            , isSection(rhs.isSection)
            , isKey(rhs.isKey)
        {}
        iniLine& operator=(iniLine&& rhs)
        {
            text1 = std::move(rhs.text1);
            text2 = std::move(rhs.text2);
            isSection = std::move(rhs.isSection);
            isKey = std::move(rhs.isKey);
            return *this;
        }

        tstring text1;
        tstring text2;
        bool isSection;
        bool isKey;
    };

    typedef std::vector<iniLine> LINES;
    typedef std::vector<size_t> SECTION_INDEX;
    typedef std::vector<size_t> KEY_INDEX;

    LINES lines;            // hold every line of the file separately
    SECTION_INDEX sections; // maintain index buffer to sections, for fast lookup
    SECTION_INDEX::iterator currentSectionIt;
    tstring filepath;       // remember the file
    bool modified;          // remember modification for automatic saving

    SECTION_INDEX::iterator _FindSection(size_t index);
    SECTION_INDEX::iterator _FindSection(const tstring& section);
    SECTION_INDEX::const_iterator _FindSection(const tstring& section) const;
    size_t _FindValue(SECTION_INDEX::iterator section, const tstring& key) const;
    void _AppendSection(const tstring& section);
    void _AppendLine(const iniLine& line);
    void _RebuildSectionIndices();
};

} // namespace neo

#endif