sprint/gtl/Registry.h

Go to the documentation of this file.

/******************************************************************************
 *  GTL: GUI Template Library 
 *    A Cross Platform C++ Wrapper for Win32 users
 *  Copyright (C) 2007-2011 Paolo Medici (www.pmx.it)
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *******************************************************************************/

#ifndef _SPRINT_REGISTRY_H
#define _SPRINT_REGISTRY_H

#include <string>

namespace sprint {
        namespace gtl {

class Registry {
protected:
        HKEY hRegKey;
        
        unsigned long result;
        
public:
        Registry(HKEY hKey, LPCSTR lpSubKey)
        {
        RegCreateKeyEx(hKey, lpSubKey,
                        0, (CHAR *) "software", 0, KEY_ALL_ACCESS, NULL, &hRegKey, &result);
        }
        
        inline ~Registry()      {
        RegCloseKey(hRegKey);   
        }

        inline Registry * CreateKey(LPCSTR lpszSubKey) const
        {
                return new Registry(hRegKey, lpszSubKey);
        }






        inline LONG Write(LPCTSTR  path, const BYTE *value, DWORD cbData)       const {
                return RegSetValueExA (hRegKey, path, 0, REG_BINARY, value, cbData);
        }

        inline LONG Write(LPCSTR path, LPCSTR str) const
        {
        return RegSetValueExA (
    hRegKey,
    path,
    0,
    REG_SZ,
    (LPBYTE) str,
    strlen(str)+1);
        }
        
        inline LONG Write(LPCSTR path, const std::string & str) const
          {
    return RegSetValueExA (
      hRegKey,
      path,
      0,
      REG_SZ,
      (LPBYTE) str.c_str(),
      str.size()+1);
    }
        
        inline LONG Write(LPCSTR path, DWORD value) const       {
        return RegSetValueExA (
                hRegKey,
                path,
                0,
                REG_DWORD,
                (LPBYTE) &value,
                sizeof(DWORD));
        }
        
        inline LONG Write(LPCSTR path, unsigned int value) const        {
        return RegSetValueExA (
                hRegKey,
                path,
                0,
                REG_DWORD,
                (LPBYTE) &value,
                sizeof(unsigned int));
        }

        inline LONG Write(LPCSTR path, int value) const {
        return RegSetValueExA (
                hRegKey,
                path,
                0,
                REG_DWORD,
                (LPBYTE) &value,
                sizeof(int));
        }

        inline LONG Write(LPCSTR path, long int value) const    {
        return RegSetValueExA (
                hRegKey,
                path,
                0,
                REG_DWORD,
                (LPBYTE) &value,
                sizeof(long int));
        }

        inline LONG Write(LPCSTR path, bool value) const        {
                DWORD dummy = value;
        return RegSetValueExA (
                hRegKey,
                path,
                0,
                REG_DWORD,
                (LPBYTE) &dummy,
                sizeof(DWORD));
        }
        
        LONG Write(LPCSTR path, float value) const;
        LONG Write(LPCSTR path, double value) const;
        



        bool Read(LPCSTR path, unsigned int *out) const;
        bool Read(LPCSTR path, int *out) const; 
        bool Read(LPCSTR path, unsigned long *out) const;
        bool Read(LPCSTR path, long *out) const;        

        bool Read(LPCSTR path, bool *out) const;                
        bool Read(LPCSTR path, char * str, unsigned int cbSize) const;
    bool Read(LPCSTR path, std::string & str) const;
        bool Read(LPCSTR path, LPBYTE out, LPDWORD lptype, LPDWORD lpsize) const;





        DWORD Read(LPCSTR path, DWORD def) const;
        bool Read(LPCSTR path, bool def) const;
        bool Read(LPCSTR path, float *value) const;
        bool Read(LPCSTR path, double *value) const;

};

}
}

#endif