MyRegistry.H

Go to the documentation of this file.

/* ***********************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2003-2004
        eMail:          sebastien.bloc@free.fr
        URL:            http://mignonsoft.free.fr

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program 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 General Public License for more details.
        http://www.gnu.org/copyleft/gpl.html
*********************************************************************************** */

#ifndef INCLUDE_REGISTRY_H
#define INCLUDE_REGISTRY_H

#include "MyString.h"
#include "MyList.h"
#pragma comment(lib, "advapi32.lib")

class MyRegistry  
{
        public:
                MyRegistry (BOOL autoCreate=FALSE);                                     
                BOOL operator= (char *nameKey) { return Open(nameKey); }
                BOOL Open(char *nameKey);                               

                void GetKeyName(MyString &result);
                BOOL Create(char *nameKey);

                void SetAutoCreate(BOOL autoCreate);
                BOOL IsAutoCreate();

                int GetValueType(char *param);
                int GetValueSize(char *param);

                // SZ | EXPAND_SZ | MULTI_SZ
                BOOL GetValue(char *param , char *result , char *defValue=NULL);                
                // SZ | EXPAND_SZ | MULTI_SZ
                BOOL GetValue(char *param, MyString &result , char *defValue=NULL);     
                // MULTI_SZ
                BOOL GetValueMulti(char *param, MyList<MyString> &result , char *defValue=NULL); 
                // EXPAND_SZ
                BOOL GetValueExpand(char *param, char *result , char *defValue=NULL); 
                // EXPAND_SZ
                BOOL GetValueExpand(char *param, MyString &result , char *defValue=NULL); 
                // DWORD | DWORD_GE | DWORD_LE
                BOOL GetValue(char *param,int *result,int defValue=0);                  
                // DWORD | DWORD_GE | DWORD_LE
                BOOL GetValue(char *param,DWORD *result,DWORD defValue=0);              
                // QWORD | QWORD_LE
                BOOL GetValue(char *param,LONGLONG *result,LONGLONG defValue=0);        
                // BINARY
                LPBYTE GetValue(char *param);
                // SZ
                BOOL GetValue(char *param,float *result,float defValue=0);
                BOOL GetValue(char *param,double *result,double defValue=0);

                BOOL SetValue(char *param);                                                                     //NONE
                BOOL SetValue(char *param,int value);                                           //DWORD
                BOOL SetValue(char *param,DWORD value);                                         //DWORD
                BOOL SetValueLittleEndian(char *param,DWORD value);                     //DWORD_LE
                BOOL SetValueBigEndian(char *param,DWORD value);                        //DWORD_BE
                BOOL SetValue(char *param,LONGLONG value);                                      //QWORD
                BOOL SetValueLittleEndian(char *param,LONGLONG value);          //QWORD_LE
                BOOL SetValue(char *param,char *value);                                         //SZ
                BOOL SetValueExpand(char *param,char *value);                           //EXPAND_SZ
                BOOL SetValueMulti(char *param,MyList<MyString> &lString);//MULTI_SZ
                BOOL SetValueMulti(char *param,char *value);                            //MULTI_SZ
                BOOL SetValue(char *param,LPBYTE data,int size);                        //BINARY
                BOOL SetValue(char *param,float result);                                        //SZ
                BOOL SetValue(char *param,double result);                                       //SZ

                BOOL DeleteValue(char *param);
                BOOL DeleteKey(char *nameKey=NULL);

                BOOL TestValue(char *param);
                BOOL TestKey();
                int GetLastError() { return m_lastError; }

                void BeginEnumKey() { m_numEnumKey = 0; }
                BOOL NextEnumKey(char *result);
                BOOL NextEnumKey(MyString &result);

                void BeginEnumValue() { m_numEnumValue = 0; }
                BOOL NextEnumValue (char *result);
                BOOL NextEnumValue (MyString &result);

                // MyString & operator() (char *param,char *type);// chargement /sauvegarde d'un parametre
                
        private:
                BOOL SetPrefixAndPostfix(char *nameKey);
                BOOL SetKeyName(char *nameKey);
                void HKeyToString (MyString &result);
                LPBYTE GetValue(char *param ,DWORD uTypeResult);
                BOOL SetValue(char *param,LPBYTE source,ULONG uTypeSource,ULONG sizeSource);


        private: 
                HKEY m_hKey;
                MyString m_postFixKey;
                BOOL m_lastError;

                int m_numEnumValue;
                int m_numEnumKey;

                BOOL m_isAutoCreate;
};

BOOL NextSubKey(MyString &key,MyString &subKey,MyString &suite);

#endif 

---