Treereg (gestion du registre comme un arbre)

Soyez le premier à donner votre avis sur cette source.

Vue 5 102 fois - Téléchargée 403 fois

Description

Gere Le registre comme un arbre un peu a la manière d'un parseur xml
Permet de créé, supprimer et modifier clef, sous clef et valeurs

Classe :

CTreeReg : Prend les infos sur la première branche et
crée le tree, retourne un ptr sur la
1ere branche

CNodeReg : Chaque tree est composé d'une node mére et
de nodes fils, cet objett reprensente une node
qui peut avoir des fils ou pas, chaque node
connait sont pére et la liste de ces fils

CKeyReg : CNodeReg dervive de cette classe, car chaque node
est aussi une clef. Chaque clef contient la liste
de ces valeurs.
(cette classe et transparente pour l'utilisateur)

CValReg : C'est le dernier element, chaque objet de cette
classe représente une valeur dans la bdr.
Cette classe gere la création, la modification
et la suppresion de valeurs dans le registre
CKeyReg contient un liste de CValReg
(cette classe et transparente pour l'utilisateur)

CDWORDReg
CStringReg
CBinaryReg
CMultiStringReg : Derive de CValReg et contienne
les données de la valeurs

Exemple d'utilisation :

CTreeReg TreeTest;

CNodeReg * pFirstNode = TreeTest.CreateTree("SOFTWARE\\Adobe",HKEY_LOCAL_MACHINE);

pFirstNode seront donc adobe vous pouvrer ensuite naviger dans les clef et les sous clef et aussi gerer les valeur de chaque clef

Il faut ajouter /Gr ds les option de compilation
Ecrit avec vc6

Source / Exemple :


//---------------------------------------------------------------------
class CKeyReg;
class CTreeReg;
class CValReg
{
friend class CKeyReg; //pour eviter que certaines fct soit publique
friend class CTreeReg;
public:

	/**********************************************************
		Ces fct peuvent etre utilisées directement depuis un
		ptr sur un CValReg

                                                                                                                      • /
virtual ~CValReg() {}; //Retourne la clef qui contient cette valeur CKeyReg * GetValKey() const {return m_pOnKey;} //Retourne le Nom, le type et les data de la valeur CString GetValName() const {return m_strValName;} //Retourne le type de la valeur int GetValType() const {return m_iTypeVal;} //Retourne un ptr sur le CTreeReg CTreeReg * GetTree(); protected : /********************************************************** Ces fct ne doivent pas etre utiliser directement, elle sont donc protected
                                                                                                                      • /
//Constructeur CValReg(CKeyReg * pKey, CString strValName, int iTypeVal); //Supprime cette valeur ds le registre //Ne pas Appeler directement bool DeleteThisKey(); //Retourne vrai si la valeur existe ds le registre bool IsExistInReg(); virtual CString GetValString() const { return "Bad Type";} virtual bool SetValData(void * pData) = 0; virtual bool SetValName(CString strNewName) = 0; virtual DWORD GetValDWORD (bool bHexa = true) const { return VAL_BAD_TYPE;} virtual const CList<CString,CString> * GetValMultiString() const {return NULL;} virtual const CList<BYTE,BYTE> * GetValBinary() const {return NULL;} protected : CString m_strValName;//Nom de la valeur int m_iTypeVal;//Type DWORD, REG_SZ, BINARY... int m_iValSize;//taille des data CKeyReg * m_pOnKey;//ptr sur la clef contenant la valeur }; //------------------------------------------------------------ class CKeyReg { public: CKeyReg(HKEY hKey, int iType); virtual ~CKeyReg(); /***********Ajout de valeurs*******************/ //Ajoute une valeur a la clef int AddValueEx(CString strValName, int iType, void * pData); //Ajoute une valeur de type REG_SZ a la clef int AddValue(CString strValName, CString strData); //Ajoute une valeur de type DWORD a la clef //La valeur dans le DWORD doit etre en hexa int AddValue(CString strValName, DWORD dwData); //Ajout une valeur de type REG_MULTI_SZ int AddValue(CString strValName, CList<CString,CString> * pList); //Ajout une valeur de type REG_BINARY int AddValue(CString strValName, CList<BYTE,BYTE> * pList); /**********************************************/ /************Recuperation des valeurs***********/ //Recupere la première valeur de la liste POSITION GetFirstValue(); //Récupere la valeur suivante ds la liste CValReg * GetNextValue(POSITION &pos); //Retourne les données d'une valeur DWORD (REG_DWORD) DWORD GetValueDWORD(CString strValName, bool bHexa = true); //Retourne les données d'une valeur string (REG_SZ) CString GetValueString(CString strValName); //Retourne un ptr constant sur la liste des //chaines d'une valeur (REG_MULTI_SZ) const CList<CString,CString> * GetValueStringList(CString strValName); //Retourne la chaine a l'index iIndex dans la liste de string //pour une valeur de type REG_MULTI_SZ //Retourne une chaine vide si index hors bornes CString GetValueStringFromList(CString strValName,int iIndex); //Retourne un ptr constant sur la liste des //BYTE d'une valeur (REG_BINARY) const CList<BYTE,BYTE> * GetValueBinary(CString strValName); //Remplit le tableau de BYTE avec les données de la valeur //retourne la taille du tableau BYTE * GetValueTabBinary(CString strValName, int * p_iSize); //Retourne une valeur par sont nom //Retourne le ptr sur la classe CValReg CValReg * GetValueByName(CString strValName); //Retourne le type de la valeur en param int GetValueType(CString strValName); /**********************************************/ /**********Modification des valeurs************/ //Toutes ces fct retourne VAL_NOT_EXIST si //vous essayer de modifier une valeur //qui n'existe pas //Ces 2 fct retourne VAL_BAD_TYPE si vous essayer de modifier //une valeurs du mauvais type ( par ex passer un CString alors //que la valeur est de type DWORD) int ChangeValueData(CString strValName, CString strNewString); int ChangeValueData(CString strValName, DWORD dwNewWord); //La liste et copier ds la memoire par la fct //Vs pouvez passer un ptr sur une variable en mem ds la pile int ChangeValueData(CString strValName, CList<CString,CString> * pList); //Permet d'ajouter une chaine a la liste d'un valeur de type //REG_MULTI_SZ, bAddHead = true pour ajouter en debut de liste int ChangeValueAddString(CString strValName, CString strData, bool bAddHead = false); //La liste et copier ds la memoire par la fct //Vs pouvez passer un ptr sur une variable en mem ds la pile int ChangeValueData(CString strValName, CList<BYTE,BYTE> * pList); //Remplace le nom d'une valeur retourne VAL_NAME_EXIST //si le nom existe deja int ChangeValueName(CString strValName, CString strValNewName); /**********************************************/ /************Suppresion des valeurs*************/ //Supprime une valeur en fct de sont nom bool DeleteValue(CString strValName); //Supprime toutes les valeurs de la clef bool DeleteAllKeyValues(); /***************** Autres ***********************/ //Retourne le nom de la clef CString GetKeyName() {return m_strKeyName;} //Retourne la date de dernière modif de la clef SYSTEMTIME GetLastModifTime() {return m_SysTime;} //Retourne le nbr de valeurs pour cette clef int GetNbVal() {return m_MapValues.GetCount();} //Retourne le HKEy de la clef HKEY GetHKEY() {return m_hKey;} /**************************************************/ //Fct non utilisateur //Reconnecte un valeur a la clef void ReconnectValue(CValReg * pVal); private : //Lit les infos de la clef void ReadKeys(HKEY hKey); //Crée un nouvelle clef void CreateKey(HKEY hKey); //Supprime une clef dans la map bool DeleteInMap(CValReg * pVal); //Changes les données de la valeur int ChangeValueDataEx(CString strValName, void * pData); protected : HKEY m_hKey; CString m_strKeyName;//Nom de la clef int m_iNextIndex;//index de la prochaine clef SYSTEMTIME m_SysTime; //Date de dernière modif //Map contenant toutes les valeurs de la clef CMap<int, int, CValReg*, CValReg*> m_MapValues; }; //------------------------------------------------------------ class CTreeReg; class CNodeReg : public CKeyReg { public: virtual ~CNodeReg(); //Créé ou lit une node et tous ces fils CNodeReg(HKEY hKey, HKEY hCommunKey, CString strPath, CString strNodeName, CNodeReg * pParentNode, int iType, CTreeReg * pTree); /************** Navigation ds l'arbre *************************/ //Retourne un ptr sur la node parent CNodeReg * GetParentNode() const; //Retourne un ptr sur une node enfant en fct de sont HKEY CNodeReg * GetChildNodeByKey(HKEY hKey); //Retourne un ptr sur une node enfant en fct de sont Nom CNodeReg * GetChildNodeByName(CString strNodeName); //Retourne le premier fils de la node POSITION GetFirstChildNode(); //Retourne le fils suivant CNodeReg * GetNextChildNode(POSITION &pos); //retourne vrai si la node a des fils bool IsFatherNode() const {return m_bIsFatherNode;} /**************************************************************/ /********************** Ajout *********************************/ //Ajoute une node fils a la node en cour //Retourne un ptr sur cette node si ok sinon null //un code d'erreur sera mis ds iRet sauf si Null CNodeReg * AddChildNode(CString strChildNodeName, int * iRet = NULL); /**************************************************************/ /********************** Suppresion ****************************/ //Supprime un node fils de la node en cour bool DeleteChildNode(CString strChildNodeName); //Supprime tous les fils de la node en cour bool DeleteAllChildNode(); //Supprime la node en cour (Attention le ptr sera null ensuite) bool DeleteThisNode(); /**************************************************************/ //Retourne le nbr de fils pour cette node int GetNbrChildNode () {return m_MapChildNode.GetCount();} //Retourne le path de la node CString GetPath() {return m_strPath;} //Sauvgarde cette node, tous ces fils et toutes leurs valeurs //dans un fichier bool SaveNodeInFile(CString m_strFileName); /************************************************************* Fct interne (l'utilisateur ne devrez pas les appeller)
                                                                                                                            • /
//Retourne le nom du fils de la clef HKEY en fct de l'index //(Attention l'index n'est pas ds l'odre d'affichage) static CString GetChildName(HKEY &hKey, int iIndex); //Retourne un ptr constant sur la liste des node enfant //Utiliser plutot les fa fct GetChildNodeByName const CMap<HKEY, HKEY, CNodeReg*, CNodeReg*> * GetPtrOnChildList() const {return &m_MapChildNode;} //Vide la liste des nodes enfants (utiliser ds CTreeReg) //ATTENTION : A manier avec precaution sinon Memory Leak //Normalement l'utilisateur ne doit pas l'utiliser void ClearNodeList() {m_MapChildNode.RemoveAll();} //Met a NULL le pere de la node m_pParentNode //Utiliser ds CTreeReg void ClearParentNode() {m_pParentNode = NULL;} //Retourne le ptr sur CTreeReg CTreeReg * GetTreeReg() {return m_pTree;} //Retourne le hTreeItem de la node ds le tree associer HTREEITEM GethTreeItem(){return m_hNodeItem;} //maj du hTreeItem de la node ds le tree associer void SethTreeItem(HTREEITEM hItem) {m_hNodeItem = hItem;} private : //Supprime la node en param de la map //Fait un DELETE sur la node bool DeleteInMap(CNodeReg * pNode); //Crée une nouvelle node void CreateNode(HKEY hKey, HKEY hCommunKey, CString strPath, CString strNodeName, CNodeReg * pParentNode); //Lit la node void ReadReg(HKEY hKey, HKEY hCommunKey, CString strPath, CString strNodeName, CNodeReg * pParentNode, int iType); //Supprime la clef du registre //Ne pas Appeler directement bool DeleteInReg(); protected : CMap<HKEY, HKEY, CNodeReg*, CNodeReg*> m_MapChildNode; CString m_strPath;//Chemin de la node bool m_bIsFatherNode;//A vrai si la node a des fils CTreeReg * m_pTree; //ptr sur le treeReg CNodeReg * m_pParentNode;//Ptr sur la node parent HKEY m_hCommunKey;//Clef Commune (HKEY_LOCAL_MACHINE par exemple) //Pour le cas ou on utilise le linkedTreeCtrl HTREEITEM m_hNodeItem; }; //------------------------------------------------------------ class CTreeReg { public: CTreeReg(); virtual ~CTreeReg(); /********************** Fct de Gestion ****************************/ //Permet de choisir le chemin du registre a analyser //strPath doit contenir le chemin complet (Ex : "SOFTWARE\\Adobe\CommunFile") //bCreate si le chemin n'existe pas il sera créé //Retourne un ptr sur la première node //ATTENTION : La première node sera la dernière clef du chemin //(Ex : "SOFTWARE\\Adobe\CommunFile") la première node sera "CommunFile" //Meme si elle n'existait pas et qu'elle a été créé, dans ce cas la première //node n'aura logiquement aucune valeurs ni aucun fils //ATTENTION 2 : si vous passer un path comm SOFTWARE seul qui contient enormement de clef //vous risquer d'avoir un Memory Overflow. CNodeReg * CreateTree(CString strPath, HKEY hCommunKey = HKEY_LOCAL_MACHINE, bool bCreate = false); //Retourne un ptr sur la node de plus haut niveau //(Celle qui contient toutes les autres, Celle retourné par CreateTree()) CNodeReg * GetPtrOnFistNode() const {return m_pFirstNode;} //Savgarde l'arbre ds un fichier reg bool SaveTreeInFile(CString m_strFileName); /********************************************************************/ /************************* Valeur virtuelle **************************/ //Si vrai a chaque modif, ajout, suppr de valeurs ds l'abre, //le registre n'est pas mit a jour et il le sera qu'a l'appel //de WriteVirtualValues() //ATTENTION : Si vs appeler UseVirtualValues(false) sans avoir //fait un WriteVirtualValues() avant , sinon les modif seront perdu !! void UseVirtualValues(bool bVirtualVal = true); //Efface la dernière action sur une valeurs (en mode virtual value) //bool Undo(); //Ecrit les valeurs virtuelle ds le registre bool WriteVirtualValues(); //---------------------------------------------------------- //Fct non utilisateur (utiliser pour le traitement interne) //---------------------------------------------------------- //Indique si on est en mode virtuel ou pas bool IsVirtualVal() {return m_bVirtualVal;} //Ajoute / supprime a la liste des valeurs virtuelle bool DelFromVirtualList(CValReg * pVal); void AddToVirtualList(CValReg * pVal); void AddToVirtualDeadList(CValReg * pVal); /*******************************************************************/ /********************** Fct de Recherches ***************************/ //Retourne chaque node ayant le nom du strKeyName const CList<CNodeReg*,CNodeReg*> * FindKeysByName(CString strKeyName); //Retourne chaque valeur ayant le Nom strValName const CList<CValReg*,CValReg*> * FindValuesByName(CString strValName); //Retourne la node correspondante au hKey CNodeReg * FindKeyByhKey(HKEY hKey); /*******************************************************************/ /********************* Tree Ctrl ***********************************/ //Permet d'assosier le treeReg a un treeCtrl //bAssocied -> chaque modif ds le treereg est reporter ds le treeCtrl //bConstruct -> Construit le tree imediatement //bClearTree -> Vide le tree avant de commancé int SetLinkedTreeCtrl(CTreeCtrl * pTreeCtrl, bool bAssocied = true, bool bConstruct = false, bool bClearTree = true); //a utiliser apres SetLinkedTreeCtrl pouyr construire le treeCtrl si bConstruct etait a false int ConstructTreeCtrl(); //retourne vrai si le treeReg est associer avec un treeCtrl bool IsAssociedTree() {return m_bAssociedTree;} //Ajoute un item ds le treeCtrl Assosier HTREEITEM AddItemInLinkedTree(HTREEITEM hFatherItem, CNodeReg * pNode); //Supprime un item ds le treeCtrl Assosier int DeleteItemInLinkedTree(HTREEITEM hItem); private : //créé recursivement le tree ctrl void RecursifTreeCreate(CNodeReg * pNode,HTREEITEM hFatherItem); /******************************************************************/ private : //Retourne la liste des clef dans le path //Chaques entrées dans le vecteur correspont //a une clef du chemin strPath std::vector<CString> GetKeysList(CString strPath); //fct recursive utiliser pour parcourir toutes les branches de l'arbre void GetNext(CNodeReg * pNode, int iSearchType); protected : //Var de gestion de l'arbre CNodeReg * m_pFirstNode;//Pointeur le la première node CString m_strStartNodeName; //Nom de la première node CString m_strPath; //Chemin de la première node HKEY m_hCommunKey;//Clef commune HKEY m_hStartKey; //Clef de la première node bool m_bValidPath;//A vrai si le chemin de SetTreeStart existe bool m_bVirtualVal;//créé des valeurs virtuelle si a vraix //Var de recherche CString m_strFind; CList<CNodeReg*,CNodeReg*> m_FindNodeList;//Liste de node correspondant a la recherche CList<CValReg*,CValReg*> m_FindValueList;//Liste de valeurs correspondant a la recherche HKEY m_hSearchKey; CNodeReg * m_pSearchNode; //Liste des valeurs virtuele CList<CValReg*,CValReg*> m_VirtualValList; //Liste des vleur a ajouter ou modifier CList<CValReg*,CValReg*> m_VirtualValToDelList; //liste des valeurs a supprimer int m_iOldAction;//utiliser pour les val virtuelles //Pour le TreeCtrl CTreeCtrl * m_pLinkedTree;// ptr vers le treectrl associer bool m_bUseTreeCtrl;//a vrai si on utilise le treectrl bool m_bAssociedTree;//a vrai si il faut mettre a jour le treectrl lors d'un modif }; /************************************************************************
                                                  • Classe type de données ************************
                                              • (Herites toutes de CValReg) ********************
                                                                                                                                                  • /
//--------------------------------------------------------------------- class CDWORDReg : public CValReg { public: CString GetName(); //Lit une valeur CDWORDReg(CKeyReg * pKey, CString strValName); //Ecrit une Valeur CDWORDReg(CKeyReg * pKey, CString strValName, DWORD dwData); //Change les datas virtual bool SetValData(void * pData); //Change le nom de la valeur virtual bool SetValName(CString strName); //Retourne la valeur sous forme hexa si bHexa = true //ou sous forme decimale bHexa = false virtual DWORD GetValDWORD(bool bHexa = true) const; protected : DWORD m_dwValue; //données de la valeur }; //--------------------------------------------------------------------- class CStringReg : public CValReg { public : //Lit une valeur CStringReg(CKeyReg * pKey, CString strValName); //Ecrit une Valeur CStringReg(CKeyReg * pKey, CString strValName, CString strData); //Change les datas virtual bool SetValData(void * pData); //Change le nom de la valeur virtual bool SetValName(CString strName); //Retourne la valeur CString virtual CString GetValString() const; protected : CString m_strValue; //données de la valeur }; //--------------------------------------------------------------------- class CMultiStringReg : public CValReg { public : //Lit une valeur CMultiStringReg(CKeyReg * pKey, CString strValName); //Ecrit une Valeur CMultiStringReg(CKeyReg * pKey, CString strValName, CList<CString,CString> * p_strDataList); //Ajoute une chaine a la liste bool AddStringToList(CString strData, bool bAddHead); //Retourne la chaine d'index iIndex dans la liste CString GetStringFromList(int iIndex); //Change les data virtual bool SetValData(void * pData); //Change le nom de la valeur virtual bool SetValName(CString strName); //Retourne la valeur sous forme d'une CList virtual const CList<CString,CString> * GetValMultiString() const; private : //Remplit m_strValueList a partir des données du registre void MakeList(unsigned char * pUChar); //retourne un ptr sur un chaine formater pour etre ecrite ds le registre unsigned char * MakeListForReg(); //Vide la liste m_strValueList void EmptyList(); //Copy la list en param dans m_strValueList void CopyList (CList<CString,CString> * p_strDataList); protected : CList<CString,CString> m_strValueList; //données de la valeur bool m_bNewData; //a faux si les data n'ont pas changer }; //--------------------------------------------------------------------- class CBinaryReg : public CValReg { public : //destructeur virtual ~CBinaryReg(); //Lit une valeur CBinaryReg(CKeyReg * pKey, CString strValName); //Ecrit une Valeur CBinaryReg(CKeyReg * pKey, CString strValName, CList<BYTE,BYTE> * pList); //Change les datas virtual bool SetValData(void * pData); //Change le nom de la valeur virtual bool SetValName(CString strName); //Retourne un Clist contenant chaque byte virtual const CList<BYTE,BYTE> * GetValBinary() const; //Remplit le tableau avec les données de la liste //Retourne la taille du tableau BYTE * GetValTabBinary(int * p_iSize); private : void CopyList(CList<BYTE,BYTE> * p_byDataList); BYTE * CBinaryReg::MakeByteTabForReg(); protected : CList<BYTE,BYTE> m_bytValueList; //données de la valeur BYTE * m_pByteTab; bool m_bNewData; };

Conclusion :


Un certain nombre de variable sont instanciées sur la pile ce qui risque de provoquer un stack overflow si vous essayer d'ouvrir un clef avec trop de sous clef comme SOFTWARE en entier par ex

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

cs_juju12
Messages postés
968
Date d'inscription
samedi 3 avril 2004
Statut
Membre
Dernière intervention
4 mars 2010
4 -
"Un certain nombre de variable sont instanciées sur la pile ce qui risque de provoquer un stack overflow si vous essayer d'ouvrir un clef avec trop de sous clef comme SOFTWARE en entier par ex "
Pourquoi déclarer sur la pile dans ce cas et pas allouer la mémoire?

Autre chose dans ta classe CValReg tu dis :
"Normalement ces fct ne doivent pas etre utiliser directement, utilisez les fct de CKeyReg"
Tu pourrais les déclarer protected/private et mettre la classe CKeyReg friend ce qui empêcherait une utilisation abusive.
kts_system
Messages postés
25
Date d'inscription
vendredi 1 décembre 2006
Statut
Membre
Dernière intervention
27 novembre 2018
-
"Pourquoi déclarer sur la pile dans ce cas et pas allouer la mémoire?"
sa m'oblige a geré la liberation, j'ai pas le temps, je le mettrai a jour quand je l'aurai.


"Tu pourrais les déclarer protected/private et mettre la classe CKeyReg friend ce qui empêcherait une utilisation abusive"

C'est vraix j'y avais pas penser, je le ferai ds la prochaine maj
kts_system
Messages postés
25
Date d'inscription
vendredi 1 décembre 2006
Statut
Membre
Dernière intervention
27 novembre 2018
-
Bon pour le stack overflow apres reflexion ce n'est pas du aux trop grand nbr de variable dans la pile.

j'ultilise une fct recursive pour créé mon abre et en faisant un petite expèrience :

La fct et appeler 250 000 fois avant d'avoir un stack overflow
A ce moment la window indique 133 000 ko ! pour l'appli
kts_system
Messages postés
25
Date d'inscription
vendredi 1 décembre 2006
Statut
Membre
Dernière intervention
27 novembre 2018
-
Bon finalement apres une ptit modif j'arrive a charger toute la branche software du registre mais l'appli finit a 222 Mo et met bien 3-4 min a se lancer

En meme temps il y a plus de 600 000 clé et un max de valeur a créé.

Je met la nouvelle version ds la journée

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.