Recherche dans un fichier ini
manta7
Messages postés
105
Date d'inscription
samedi 25 janvier 2003
Statut
Membre
Dernière intervention
13 décembre 2008
-
13 févr. 2005 à 17:34
alkove Messages postés 37 Date d'inscription jeudi 27 mars 2003 Statut Membre Dernière intervention 6 mai 2005 - 15 févr. 2005 à 08:31
alkove Messages postés 37 Date d'inscription jeudi 27 mars 2003 Statut Membre Dernière intervention 6 mai 2005 - 15 févr. 2005 à 08:31
8 réponses
yoyo269
Messages postés
1403
Date d'inscription
lundi 23 février 2004
Statut
Membre
Dernière intervention
11 janvier 2009
2
13 févr. 2005 à 20:04
13 févr. 2005 à 20:04
Salut manta7,
Si tu connais le format des données contenues dans le .ini, il te suffit de lire le fichier ligne par ligne ou caractères par caractère ou autre méthode selon le format.
YOYO, @+.
YOYO
Si tu connais le format des données contenues dans le .ini, il te suffit de lire le fichier ligne par ligne ou caractères par caractère ou autre méthode selon le format.
YOYO, @+.
YOYO
NitRic
Messages postés
402
Date d'inscription
mardi 1 mai 2001
Statut
Membre
Dernière intervention
15 août 2011
14 févr. 2005 à 01:47
14 févr. 2005 à 01:47
/*************************************************
*
Ce n'est pas parfait comme code
mais ca te donne une idée de
comment proceder.
Le code ne prend que les clées/données.
Les sections ne sont pas gardées.
Je n'est pas testé le code, désolé.
Bloc-notes Power!
*
*************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define _IS_COMMENT(str) ( *(char *)str == ';' )
#define _IS_SECTION(str) ( *(char *)str == '[' && strchr( (char *)str, ']' ) )
#define _IS_KEY_VALUE(str) ( NULL != strchr( (char *)str, '=' ) )
typedef struct _ini_data
{
char * key;
char * value;
}INI_DATA;
typedef struct _ini
{
INI_DATA * data;
size_t count;
size_t size;
}INI;
char * skipspace( const char * str )
{
while ( *str && !(*str - ' ') )
++str;
return (char *) str;
}
int add_key_value( INI * ini, const char * key, const char * value )
{
INI_DATA * d;
/* manque de place ? */
if ( ini->count-1 >= ini->size )
{
{ /* augmente la taille du tableau */
INI_DATA * nd;
if ( !(nd = realloc( ini->data, (ini->size + 100) * sizeof(INI_DATA) )) )
return -1;
ini->data = nd;
ini->size += 100;
}
}
d = &(ini->data[ ini->count ]); if ( d->key _strdup( key ) && d->value _strdup( value ) )
{
++(ini->count);
return 0;
}
if ( d->key )
free( d->key );
return -1;
}
int read_ini_file( INI * ini, const char * fname )
{
FILE * fd;
char buffer[4097];
char * ptr;
char * kptr, * vptr;
if ( !(fd = fopen(fname, "rt")) )
return -1;
while ( !feof( fd ) )
{
if ( !fgets( buffer, 4096, fd ) )
break;
ptr = skipspace( buffer );
if ( *ptr && !_IS_COMMENT( ptr ) )
{
if ( _IS_KEY_VALUE( ptr ) )
{
kptr = ptr; /* la clée */
vptr = strchr( ptr, '=' ); /* la valeur/donnée */
*vptr++ = '\0'; /* supprime le caractère `=` */
if ( (ptr = strchr( vptr, '\n' )) )
*ptr = '\0'; /* supprime le retour à la ligne */
if ( (ptr = strchr( vptr, ';' )) )
*ptr = '\0'; /* supprime le commentaire s'il y en à un */
if ( add_key_value( ini, kptr, vptr ) )
break; /* ERROR!!! */
}
else if ( _IS_SECTION( ptr ) )
{
/* continue; */
}
}
}
fclose( fd );
return 0; /* no error */
}
void free_ini( INI * ini )
{
INI_DATA * p;
if ( (p = ini->data) )
{
for ( ; p < ini->data + ini->count; p++ )
{
if ( p->key )
free( p->key );
if ( p->value )
free( p->value );
}
free( ini->data );
}
}
int main( int argc, char * argv[] )
{
INI ini;
INI_DATA * p;
ini.size = 100;
if ( !(ini.data = calloc( ini.size * sizeof(INI_DATA) )) )
return -1;
ini.count = 0;
if ( !read_ini_file( &ini, ".\\mon_fichier.ini" ) )
puts("SUCCESS");
else
puts("ERROR");
for ( p = ini.data; p < ini.data + ini.count; p++ )
printf("%s => %s\n", p->key, p->value);
/* ou encore:
for ( size_t i = 0; i < ini.count; i++ )
printf("%s => %s\n", ini.data[i].key, ini.data[i].value);
*/
printf("count => %u\nsize => %u\n", ini.count, ini.size);
printf("realloue %u fois\n", (ini.size / 100));
free_ini( &ini );
return 0;
}
~(.:: NitRic ::.)~
*
Ce n'est pas parfait comme code
mais ca te donne une idée de
comment proceder.
Le code ne prend que les clées/données.
Les sections ne sont pas gardées.
Je n'est pas testé le code, désolé.
Bloc-notes Power!
*
*************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define _IS_COMMENT(str) ( *(char *)str == ';' )
#define _IS_SECTION(str) ( *(char *)str == '[' && strchr( (char *)str, ']' ) )
#define _IS_KEY_VALUE(str) ( NULL != strchr( (char *)str, '=' ) )
typedef struct _ini_data
{
char * key;
char * value;
}INI_DATA;
typedef struct _ini
{
INI_DATA * data;
size_t count;
size_t size;
}INI;
char * skipspace( const char * str )
{
while ( *str && !(*str - ' ') )
++str;
return (char *) str;
}
int add_key_value( INI * ini, const char * key, const char * value )
{
INI_DATA * d;
/* manque de place ? */
if ( ini->count-1 >= ini->size )
{
{ /* augmente la taille du tableau */
INI_DATA * nd;
if ( !(nd = realloc( ini->data, (ini->size + 100) * sizeof(INI_DATA) )) )
return -1;
ini->data = nd;
ini->size += 100;
}
}
d = &(ini->data[ ini->count ]); if ( d->key _strdup( key ) && d->value _strdup( value ) )
{
++(ini->count);
return 0;
}
if ( d->key )
free( d->key );
return -1;
}
int read_ini_file( INI * ini, const char * fname )
{
FILE * fd;
char buffer[4097];
char * ptr;
char * kptr, * vptr;
if ( !(fd = fopen(fname, "rt")) )
return -1;
while ( !feof( fd ) )
{
if ( !fgets( buffer, 4096, fd ) )
break;
ptr = skipspace( buffer );
if ( *ptr && !_IS_COMMENT( ptr ) )
{
if ( _IS_KEY_VALUE( ptr ) )
{
kptr = ptr; /* la clée */
vptr = strchr( ptr, '=' ); /* la valeur/donnée */
*vptr++ = '\0'; /* supprime le caractère `=` */
if ( (ptr = strchr( vptr, '\n' )) )
*ptr = '\0'; /* supprime le retour à la ligne */
if ( (ptr = strchr( vptr, ';' )) )
*ptr = '\0'; /* supprime le commentaire s'il y en à un */
if ( add_key_value( ini, kptr, vptr ) )
break; /* ERROR!!! */
}
else if ( _IS_SECTION( ptr ) )
{
/* continue; */
}
}
}
fclose( fd );
return 0; /* no error */
}
void free_ini( INI * ini )
{
INI_DATA * p;
if ( (p = ini->data) )
{
for ( ; p < ini->data + ini->count; p++ )
{
if ( p->key )
free( p->key );
if ( p->value )
free( p->value );
}
free( ini->data );
}
}
int main( int argc, char * argv[] )
{
INI ini;
INI_DATA * p;
ini.size = 100;
if ( !(ini.data = calloc( ini.size * sizeof(INI_DATA) )) )
return -1;
ini.count = 0;
if ( !read_ini_file( &ini, ".\\mon_fichier.ini" ) )
puts("SUCCESS");
else
puts("ERROR");
for ( p = ini.data; p < ini.data + ini.count; p++ )
printf("%s => %s\n", p->key, p->value);
/* ou encore:
for ( size_t i = 0; i < ini.count; i++ )
printf("%s => %s\n", ini.data[i].key, ini.data[i].value);
*/
printf("count => %u\nsize => %u\n", ini.count, ini.size);
printf("realloue %u fois\n", (ini.size / 100));
free_ini( &ini );
return 0;
}
~(.:: NitRic ::.)~
magic_Nono
Messages postés
1878
Date d'inscription
jeudi 16 octobre 2003
Statut
Membre
Dernière intervention
16 mars 2011
14 févr. 2005 à 14:05
14 févr. 2005 à 14:05
j'ai une classe qui fait ça....
c'est pour eVC (PDA) mais ça marchera directement sur VC je pense.
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif /* _DEBUG */
#include "stdafx.h"
//#include "QualiTel.hpp"
#include "GestionFichierIni.hpp"
BFichierIniPDA::BFichierIniPDA(LPCTSTR lpFileName)
{
/// ------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::BFichierIniPDA(LPCTSTR lpFileName) ----------------
/// ------------------------------------------------------------------------------------
/// ----- Objectif : Constructeur de la classe : BFichierIniPDA
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PostCond : Toutes les variables de la classe doivent être instanciées avec une valeur par défaut ou contextuelle
/// ----- Etat : 1 (-1<0<1<2)
/// ------------------------------------------------------------------------------------
/// ----- LPCTSTR lpFileName : Chemin complet + nom du fichier de style INI
/// ------------------------------------------------------------------------------------
/// ----- Var Utilisées de la classe (1) : m_sNomFichier
/// ----- Var Muettes (cf.partie préc) (1) : lpFileName
/// ----- Var In (1) : lpFileName
/// ----- Var Out (1) : m_sNomFichier
m_sNomFichier=lpFileName;
// Création de la map en lisant le fichier
initArbre();
}
BFichierIniPDA::~BFichierIniPDA()
{
/// -------------------------------------------------------------------
/// ---------------- BFichierIniPDA::~BFichierIniPDA() ----------------
/// -------------------------------------------------------------------
/// ----- Objectif : Destructeur de la classe : BFichierIniPDA
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PostCond : Toutes les variables de la classe sont détruites
/// ----- Etat : 1 (-1<0<1<2)
/// -------------------------------------------------------------------
m_mapValeurs.RemoveAll();
}
bool BFichierIniPDA::lireLigne()
{
/// ---------------------------------------------------------------------
/// ---------------- BFichierIniPDA::lireLigne() -> bool ----------------
/// ---------------------------------------------------------------------
/// ----- Objectif : Lire une ligne du fichier
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// ---------------------------------------------------------------------
/// ----- retour (bool) : succès
/// ---------------------------------------------------------------------
/// ----- Var Utilisées de la classe (1) : m_sContenuLigne
/// ----- Var Internes à la fonction (3) : c ,l_bFinBoucle ,nbRead
/// ----- Var In Globales Constantes (1) : WCHAR
/// ----- Var Out (1) : m_sContenuLigne
bool l_bFinBoucle=false;
m_sContenuLigne.Empty();
int nbRead=0;
while(l_bFinBoucle!=true)
{
unsigned char c;
nbRead=m_fichier.Read(&c,1);
if(nbRead==1)
{
if(c==10)
/// algo : fin de ligne
l_bFinBoucle=true;
else
if(c!=13)
/// algo : ignorer '\r'
m_sContenuLigne+=(WCHAR)c;
}
else
/// algo : fin de fichier
l_bFinBoucle=true;
}
return(nbRead==1 || m_sContenuLigne.GetLength()>0);
}
bool BFichierIniPDA::isSection()const
{
/// ---------------------------------------------------------------------
/// ---------------- BFichierIniPDA::isSection() -> bool ----------------
/// ---------------------------------------------------------------------
/// ----- Objectif : Teste si la ligne est une section
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// ---------------------------------------------------------------------
/// ----- retour (bool) : section?
/// ---------------------------------------------------------------------
return(!m_sContenuLigne.IsEmpty() && m_sContenuLigne.GetAt(0)=='[');
}
bool BFichierIniPDA::isCommentaire()const
{
/// -------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::isCommentaire() -> bool ----------------
/// -------------------------------------------------------------------------
/// ----- Objectif : Teste si la ligne est un commentaire
/// ----- Explic : commentaire = ligne commençant par ";"
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// -------------------------------------------------------------------------
/// ----- retour (bool) : cf objectif
/// -------------------------------------------------------------------------
return(!m_sContenuLigne.IsEmpty() && m_sContenuLigne.GetAt(0)==';');
}
void BFichierIniPDA::addEntree()
{
/// -------------------------------------------------------------
/// ---------------- BFichierIniPDA::addEntree() ----------------
/// -------------------------------------------------------------
/// ----- Objectif : Ajouter une entrée dans la map du fichier
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// -------------------------------------------------------------
/// ----- Var Utilisées de la classe (3) : m_sCle ,m_sValeurEntree ,m_tailleArbre
/// ----- Var Internes à la fonction (1) : cle
/// ----- Var In (3) : m_sCle ,m_sValeurEntree ,m_tailleArbre
m_tailleArbre++;
CString cle=getNomSection()+';';
cle+=m_sCle;
m_mapValeurs.SetAt(cle,m_sValeurEntree);
}
void BFichierIniPDA::initArbre()
{
/// -------------------------------------------------------------
/// ---------------- BFichierIniPDA::initArbre() ----------------
/// -------------------------------------------------------------
/// ----- Objectif : Lecture du fichier et création de la map représentant l'arbre du fichier
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// -------------------------------------------------------------
/// ----- Var : classes externes dont on appelle des méthodes (1) : CFile
/// ----- Var Utilisées de la classe (7) : m_isOpen ,m_sCle ,m_sContenuLigne ,m_sNomFichier ,m_sSection ,m_sValeurEntree ,m_tailleArbre
/// ----- Var In (2) : m_sContenuLigne ,m_sNomFichier
/// ----- Var In Globales (1) : modeRead
/// ----- Var Out (5) : m_isOpen ,m_sCle ,m_sSection ,m_sValeurEntree ,m_tailleArbre
m_tailleArbre=0;
m_mapValeurs.RemoveAll();
m_isOpen=(0!=m_fichier.Open(m_sNomFichier,CFile::modeRead));
if(m_isOpen)
{
// Génération de la map des valeurs
while(lireLigne())
if(!m_sContenuLigne.IsEmpty() && !isCommentaire())
if(isSection())
m_sSection=m_sContenuLigne;
else
{
// On est sur une entrée potentielle
int positionEgale=m_sContenuLigne.Find('=');
if(positionEgale>=0)
{
// On est sur une entrée!
m_sCle=m_sContenuLigne.Left(positionEgale);
m_sValeurEntree=m_sContenuLigne.Mid(positionEgale+1);
addEntree();
}
}
m_fichier.Close();
}
}
void BFichierIniPDA::copyArbre(LPCTSTR nomFichier)
{
/// -------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::copyArbre(LPCTSTR nomFichier) ----------------
/// -------------------------------------------------------------------------------
/// ----- Objectif : Recopier la map dans le fichier d'origine
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// ----- TODO : prise en compte des commentaires !!!
/// -------------------------------------------------------------------------------
/// ----- LPCTSTR nomFichier : Chemin complet + nom du fichier de style INI
/// -------------------------------------------------------------------------------
/// ----- Var : classes externes dont on appelle des méthodes (1) : CFile
/// ----- Var Utilisées de la classe (1) : m_isOpen
/// ----- Var Muettes (cf.partie préc) (1) : nomFichier
/// ----- Var Internes à la fonction (11) : l_Index1 ,l_Index2 ,l_iIndex ,l_iPositionVirgule ,l_sBuffer ,l_sCle ,l_sIdentifiant ,l_sMapBuffer ,l_sSection ,l_sValeur ,l_usCaractere
/// ----- Var In (1) : nomFichier
/// ----- Var In Globales (2) : modeCreate ,modeWrite
/// ----- Var Out (1) : m_isOpen
/// algo : Réinit a 0 du fichier si il existe, sinon création du fichier Accés en écriture
m_isOpen=(0!=m_fichier.Open(nomFichier,CFile::modeCreate|CFile::modeWrite));
if(m_isOpen)
{
CMapStringToString l_sMapBuffer;
CString l_sValeur,l_sIdentifiant,l_sSection,l_sCle,l_sBuffer;
POSITION l_Index1,l_Index2;
int l_iPositionVirgule,l_iIndex;
unsigned short l_usCaractere;
/// algo : Récup toutes les sections
l_sMapBuffer.RemoveAll();
l_Index1=m_mapValeurs.GetStartPosition();
while(l_Index1 != NULL)
{
m_mapValeurs.GetNextAssoc(l_Index1,l_sIdentifiant,l_sValeur);
// contenu de l_sKey -> section;clé
l_iPositionVirgule=l_sIdentifiant.Find(';');
l_sSection=l_sIdentifiant.Left(l_iPositionVirgule);
l_sMapBuffer.SetAt(l_sSection,NULL);
}
/// algo : Copie les sections dans le fichier
l_Index1=l_sMapBuffer.GetStartPosition();
while(l_Index1 != NULL)
{
l_sMapBuffer.GetNextAssoc( l_Index1,l_sSection,l_sValeur);
m_fichier.Write("[",1);
// Copie caractère par caractère
for(l_iIndex=0;l_iIndex<l_sSection.GetLength();l_iIndex++)
{
l_usCaractere=l_sSection.GetAt(l_iIndex);
m_fichier.Write(&l_usCaractere,1);
}
m_fichier.Write("]",1);
m_fichier.Write("\r\n",2);
/// algo : Pour chaques sections
l_Index2=m_mapValeurs.GetStartPosition();
while(l_Index2 != NULL)
{
/// algo : Recherche de chaques clés et valeurs associées à cette section
/// algo : copie dans le fichier
m_mapValeurs.GetNextAssoc(l_Index2,l_sIdentifiant,l_sValeur);
// contenu de l_sKey -> section;clé
l_iPositionVirgule=l_sIdentifiant.Find(';');
/// algo : Si c'est la bonne section
if(l_sSection.Compare(l_sIdentifiant.Left(l_iPositionVirgule))==0)
{
/// algo : écrit la clé et la valeur ds le fic
l_sCle=l_sIdentifiant.Mid(l_iPositionVirgule+1,l_sIdentifiant.GetLength()-1);
// Copie caractère par caractère
for(l_iIndex=0;l_iIndex<l_sCle.GetLength();l_iIndex++)
{
l_usCaractere=l_sCle.GetAt(l_iIndex);
m_fichier.Write(&l_usCaractere,1);
}
m_fichier.Write("=",1);
// Copie caractère par caractère
for(l_iIndex=0;l_iIndex<l_sValeur.GetLength();l_iIndex++)
{
l_usCaractere=l_sValeur.GetAt(l_iIndex);
m_fichier.Write(&l_usCaractere,1);
}
m_fichier.Write("\r\n",2);
}
}
m_fichier.Write("\r\n",2);
}
m_fichier.Close();
}
}
CString BFichierIniPDA::getNomSection()const
{
/// ----------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::getNomSection() -> CString ----------------
/// ----------------------------------------------------------------------------
/// ----- Objectif : Récupérer le nom de la section
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// ----------------------------------------------------------------------------
/// ----- retour (CString) : Nom de la section sans crochets
/// ----------------------------------------------------------------------------
/// ----- Var Utilisées de la classe (1) : m_sSection
/// ----- Var Internes à la fonction (1) : nomSection
/// ----- Var In (1) : m_sSection
CString nomSection=m_sSection;
nomSection.Remove('[');
nomSection.Remove(']');
return(nomSection);
}
int BFichierIniPDA::get(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpDefault,LPTSTR lpReturnedString)const
{
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::get(LPCTSTR lpAppName ,LPCTSTR lpKeyName ,LPCTSTR lpDefault ,LPTSTR lpReturnedString) -> int ----------------
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// ----- Objectif : Lire une chaine dans un fichier de style INI
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// ----- LPCTSTR lpAppName : section
/// ----- LPCTSTR lpKeyName : clef
/// ----- LPCTSTR lpDefault : Valeur par défaut
/// ----- LPTSTR lpReturnedString : Pointeur sur buffer qui va contenir la valeur lue
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// ----- retour (int) : Taille de la chaine lue
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// ----- Var Muettes (cf.partie préc) (4) : lpAppName ,lpDefault ,lpKeyName ,lpReturnedString
/// ----- Var Internes à la fonction (3) : cle ,l_iValeurRetour ,valeur
/// ----- Var Utilisées par adresse (1) : lpReturnedString
/// ----- Var In (3) : lpAppName ,lpDefault ,lpKeyName
/// ----- Var In-Out (1) : lpReturnedString
int l_iValeurRetour=0;
CString cle=lpAppName;
cle+=';';
cle+=lpKeyName;
CString valeur;
if(m_mapValeurs.Lookup(cle,valeur))
{
// on a bien trouvé l'entrée
wcsncpy(lpReturnedString,valeur,valeur.GetLength());
// Ajout du caractère de fin de chaine
lpReturnedString[valeur.GetLength()]='\0';
l_iValeurRetour=valeur.GetLength();
}
else // On n'a pas trouve l'entrée
wcsncpy(lpReturnedString,lpDefault,wcslen(lpDefault));
return(l_iValeurRetour);
}
void BFichierIniPDA::set(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpString)
{
/// -------------------------------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::set(LPCTSTR lpAppName ,LPCTSTR lpKeyName ,LPCTSTR lpString) ----------------
/// -------------------------------------------------------------------------------------------------------------
/// ----- Objectif : Ecrire une chaine dans un fichier de style INI
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// -------------------------------------------------------------------------------------------------------------
/// ----- LPCTSTR lpAppName : section
/// ----- LPCTSTR lpKeyName : clé
/// ----- LPCTSTR lpString : valeur
/// -------------------------------------------------------------------------------------------------------------
/// ----- Var Utilisées de la classe (1) : m_sNomFichier
/// ----- Var Muettes (cf.partie préc) (3) : lpAppName ,lpKeyName ,lpString
/// ----- Var Internes à la fonction (1) : cle
/// ----- Var In (4) : lpAppName ,lpKeyName ,lpString ,m_sNomFichier
CString cle=lpAppName;
cle+=';';
cle+=lpKeyName;
// Inscription d'une nouvelle chaîne ou mise à jour si elle existe déjà
m_mapValeurs.SetAt(cle,lpString);
// Mise à jour du fichier
copyArbre(m_sNomFichier);
}
int BFichierIniPDA::getInt(LPCTSTR lpAppName,LPCTSTR lpKeyName,int nDefault)const
{
/// -------------------------------------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::getInt(LPCTSTR lpAppName ,LPCTSTR lpKeyName ,int nDefault) -> int ----------------
/// -------------------------------------------------------------------------------------------------------------------
/// ----- Objectif : Lire un entier dans un fichier de style INI
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// -------------------------------------------------------------------------------------------------------------------
/// ----- LPCTSTR lpAppName : Nom de la section
/// ----- LPCTSTR lpKeyName : Nom de la clé
/// ----- int nDefault(par défaut : '0') : Valeur par défaut
/// -------------------------------------------------------------------------------------------------------------------
/// ----- retour (int) : Valeur lue
/// -------------------------------------------------------------------------------------------------------------------
/// ----- Var Muettes (cf.partie préc) (3) : lpAppName ,lpKeyName ,nDefault
/// ----- Var Internes à la fonction (3) : cle ,l_iValeurRetour ,valeur
/// ----- Var In (3) : lpAppName ,lpKeyName ,nDefault
int l_iValeurRetour=nDefault;
CString cle=lpAppName;
cle+=';';
cle+=lpKeyName;
CString valeur;
if(m_mapValeurs.Lookup(cle,valeur))
// on a bien trouvé l'entrée
if(!valeur.IsEmpty())
l_iValeurRetour=_tcstol(valeur,NULL,0);
return(l_iValeurRetour);
}
void BFichierIniPDA::setInt(LPCTSTR lpAppName,LPCTSTR lpKeyName,int nValeur)
{
/// -----------------------------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::setInt(LPCTSTR lpAppName ,LPCTSTR lpKeyName ,int nValeur) ----------------
/// -----------------------------------------------------------------------------------------------------------
/// ----- Objectif : Ecrire un entier dans un fichier de style INI
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// -----------------------------------------------------------------------------------------------------------
/// ----- LPCTSTR lpAppName : section
/// ----- LPCTSTR lpKeyName : clé
/// ----- int nValeur : Valeur à écrire
/// -----------------------------------------------------------------------------------------------------------
/// ----- Var Utilisées de la classe (1) : m_sNomFichier
/// ----- Var Muettes (cf.partie préc) (3) : lpAppName ,lpKeyName ,nValeur
/// ----- Var Internes à la fonction (2) : cle ,valeur
/// ----- Var In (4) : lpAppName ,lpKeyName ,m_sNomFichier ,nValeur
CString cle=lpAppName;
cle+=';';
cle+=lpKeyName;
CString valeur;
valeur.Format(_T("%d"),nValeur);
// Inscription d'une nouvelle valeur ou mise à jour si elle existe déjà
m_mapValeurs.SetAt(cle,valeur);
// Mise à jour du fichier
copyArbre(m_sNomFichier);
}
void BFichierIniPDA::delSection(CString p_sSectionSupprime)
{
/// ----------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::delSection(CString p_sSectionSupprime) ----------------
/// ----------------------------------------------------------------------------------------
/// ----- Objectif : Supprimer une section entière
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// ----------------------------------------------------------------------------------------
/// ----- CString p_sSectionSupprime : Nom de la section à supprimer
/// ----------------------------------------------------------------------------------------
/// ----- Var Utilisées de la classe (1) : m_sNomFichier
/// ----- Var Muettes (cf.partie préc) (1) : p_sSectionSupprime
/// ----- Var Internes à la fonction (4) : l_Position ,l_iIndex ,l_sSection ,l_sValeur
/// ----- Var In (1) : m_sNomFichier
POSITION l_Position;
int l_iIndex;
CString l_sSection;
CString l_sValeur;
l_Position=m_mapValeurs.GetStartPosition();
while(l_Position!=NULL)
{
m_mapValeurs.GetNextAssoc(l_Position,l_sSection,l_sValeur);
// Recherche de la position de la virgule qui sépare la section de la clé
l_iIndex=l_sSection.Find(_T(";"),0);
// Compare la section à supprimer et la section actuelle
if(p_sSectionSupprime.Compare(l_sSection.Left(l_iIndex))==0)
// supprime
m_mapValeurs.RemoveKey(l_sSection);
}
copyArbre(m_sNomFichier);
}
bool BFichierIniPDA::isVide()const
{
/// ------------------------------------------------------------------
/// ---------------- BFichierIniPDA::isVide() -> bool ----------------
/// ------------------------------------------------------------------
/// ----- Objectif : fichier vide?
/// ----- Auteur(s) : Magic_Nono 10/02/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// ------------------------------------------------------------------
/// ----- retour (bool) : cf.objectif
/// ------------------------------------------------------------------
/// ----- Var Utilisées de la classe (1) : m_tailleArbre
/// ----- Var In (1) : m_tailleArbre
return(0==m_tailleArbre);
}
Magic Nono: l'informagicien!
c'est pour eVC (PDA) mais ça marchera directement sur VC je pense.
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif /* _DEBUG */
#include "stdafx.h"
//#include "QualiTel.hpp"
#include "GestionFichierIni.hpp"
BFichierIniPDA::BFichierIniPDA(LPCTSTR lpFileName)
{
/// ------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::BFichierIniPDA(LPCTSTR lpFileName) ----------------
/// ------------------------------------------------------------------------------------
/// ----- Objectif : Constructeur de la classe : BFichierIniPDA
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PostCond : Toutes les variables de la classe doivent être instanciées avec une valeur par défaut ou contextuelle
/// ----- Etat : 1 (-1<0<1<2)
/// ------------------------------------------------------------------------------------
/// ----- LPCTSTR lpFileName : Chemin complet + nom du fichier de style INI
/// ------------------------------------------------------------------------------------
/// ----- Var Utilisées de la classe (1) : m_sNomFichier
/// ----- Var Muettes (cf.partie préc) (1) : lpFileName
/// ----- Var In (1) : lpFileName
/// ----- Var Out (1) : m_sNomFichier
m_sNomFichier=lpFileName;
// Création de la map en lisant le fichier
initArbre();
}
BFichierIniPDA::~BFichierIniPDA()
{
/// -------------------------------------------------------------------
/// ---------------- BFichierIniPDA::~BFichierIniPDA() ----------------
/// -------------------------------------------------------------------
/// ----- Objectif : Destructeur de la classe : BFichierIniPDA
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PostCond : Toutes les variables de la classe sont détruites
/// ----- Etat : 1 (-1<0<1<2)
/// -------------------------------------------------------------------
m_mapValeurs.RemoveAll();
}
bool BFichierIniPDA::lireLigne()
{
/// ---------------------------------------------------------------------
/// ---------------- BFichierIniPDA::lireLigne() -> bool ----------------
/// ---------------------------------------------------------------------
/// ----- Objectif : Lire une ligne du fichier
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// ---------------------------------------------------------------------
/// ----- retour (bool) : succès
/// ---------------------------------------------------------------------
/// ----- Var Utilisées de la classe (1) : m_sContenuLigne
/// ----- Var Internes à la fonction (3) : c ,l_bFinBoucle ,nbRead
/// ----- Var In Globales Constantes (1) : WCHAR
/// ----- Var Out (1) : m_sContenuLigne
bool l_bFinBoucle=false;
m_sContenuLigne.Empty();
int nbRead=0;
while(l_bFinBoucle!=true)
{
unsigned char c;
nbRead=m_fichier.Read(&c,1);
if(nbRead==1)
{
if(c==10)
/// algo : fin de ligne
l_bFinBoucle=true;
else
if(c!=13)
/// algo : ignorer '\r'
m_sContenuLigne+=(WCHAR)c;
}
else
/// algo : fin de fichier
l_bFinBoucle=true;
}
return(nbRead==1 || m_sContenuLigne.GetLength()>0);
}
bool BFichierIniPDA::isSection()const
{
/// ---------------------------------------------------------------------
/// ---------------- BFichierIniPDA::isSection() -> bool ----------------
/// ---------------------------------------------------------------------
/// ----- Objectif : Teste si la ligne est une section
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// ---------------------------------------------------------------------
/// ----- retour (bool) : section?
/// ---------------------------------------------------------------------
return(!m_sContenuLigne.IsEmpty() && m_sContenuLigne.GetAt(0)=='[');
}
bool BFichierIniPDA::isCommentaire()const
{
/// -------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::isCommentaire() -> bool ----------------
/// -------------------------------------------------------------------------
/// ----- Objectif : Teste si la ligne est un commentaire
/// ----- Explic : commentaire = ligne commençant par ";"
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// -------------------------------------------------------------------------
/// ----- retour (bool) : cf objectif
/// -------------------------------------------------------------------------
return(!m_sContenuLigne.IsEmpty() && m_sContenuLigne.GetAt(0)==';');
}
void BFichierIniPDA::addEntree()
{
/// -------------------------------------------------------------
/// ---------------- BFichierIniPDA::addEntree() ----------------
/// -------------------------------------------------------------
/// ----- Objectif : Ajouter une entrée dans la map du fichier
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// -------------------------------------------------------------
/// ----- Var Utilisées de la classe (3) : m_sCle ,m_sValeurEntree ,m_tailleArbre
/// ----- Var Internes à la fonction (1) : cle
/// ----- Var In (3) : m_sCle ,m_sValeurEntree ,m_tailleArbre
m_tailleArbre++;
CString cle=getNomSection()+';';
cle+=m_sCle;
m_mapValeurs.SetAt(cle,m_sValeurEntree);
}
void BFichierIniPDA::initArbre()
{
/// -------------------------------------------------------------
/// ---------------- BFichierIniPDA::initArbre() ----------------
/// -------------------------------------------------------------
/// ----- Objectif : Lecture du fichier et création de la map représentant l'arbre du fichier
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// -------------------------------------------------------------
/// ----- Var : classes externes dont on appelle des méthodes (1) : CFile
/// ----- Var Utilisées de la classe (7) : m_isOpen ,m_sCle ,m_sContenuLigne ,m_sNomFichier ,m_sSection ,m_sValeurEntree ,m_tailleArbre
/// ----- Var In (2) : m_sContenuLigne ,m_sNomFichier
/// ----- Var In Globales (1) : modeRead
/// ----- Var Out (5) : m_isOpen ,m_sCle ,m_sSection ,m_sValeurEntree ,m_tailleArbre
m_tailleArbre=0;
m_mapValeurs.RemoveAll();
m_isOpen=(0!=m_fichier.Open(m_sNomFichier,CFile::modeRead));
if(m_isOpen)
{
// Génération de la map des valeurs
while(lireLigne())
if(!m_sContenuLigne.IsEmpty() && !isCommentaire())
if(isSection())
m_sSection=m_sContenuLigne;
else
{
// On est sur une entrée potentielle
int positionEgale=m_sContenuLigne.Find('=');
if(positionEgale>=0)
{
// On est sur une entrée!
m_sCle=m_sContenuLigne.Left(positionEgale);
m_sValeurEntree=m_sContenuLigne.Mid(positionEgale+1);
addEntree();
}
}
m_fichier.Close();
}
}
void BFichierIniPDA::copyArbre(LPCTSTR nomFichier)
{
/// -------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::copyArbre(LPCTSTR nomFichier) ----------------
/// -------------------------------------------------------------------------------
/// ----- Objectif : Recopier la map dans le fichier d'origine
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// ----- TODO : prise en compte des commentaires !!!
/// -------------------------------------------------------------------------------
/// ----- LPCTSTR nomFichier : Chemin complet + nom du fichier de style INI
/// -------------------------------------------------------------------------------
/// ----- Var : classes externes dont on appelle des méthodes (1) : CFile
/// ----- Var Utilisées de la classe (1) : m_isOpen
/// ----- Var Muettes (cf.partie préc) (1) : nomFichier
/// ----- Var Internes à la fonction (11) : l_Index1 ,l_Index2 ,l_iIndex ,l_iPositionVirgule ,l_sBuffer ,l_sCle ,l_sIdentifiant ,l_sMapBuffer ,l_sSection ,l_sValeur ,l_usCaractere
/// ----- Var In (1) : nomFichier
/// ----- Var In Globales (2) : modeCreate ,modeWrite
/// ----- Var Out (1) : m_isOpen
/// algo : Réinit a 0 du fichier si il existe, sinon création du fichier Accés en écriture
m_isOpen=(0!=m_fichier.Open(nomFichier,CFile::modeCreate|CFile::modeWrite));
if(m_isOpen)
{
CMapStringToString l_sMapBuffer;
CString l_sValeur,l_sIdentifiant,l_sSection,l_sCle,l_sBuffer;
POSITION l_Index1,l_Index2;
int l_iPositionVirgule,l_iIndex;
unsigned short l_usCaractere;
/// algo : Récup toutes les sections
l_sMapBuffer.RemoveAll();
l_Index1=m_mapValeurs.GetStartPosition();
while(l_Index1 != NULL)
{
m_mapValeurs.GetNextAssoc(l_Index1,l_sIdentifiant,l_sValeur);
// contenu de l_sKey -> section;clé
l_iPositionVirgule=l_sIdentifiant.Find(';');
l_sSection=l_sIdentifiant.Left(l_iPositionVirgule);
l_sMapBuffer.SetAt(l_sSection,NULL);
}
/// algo : Copie les sections dans le fichier
l_Index1=l_sMapBuffer.GetStartPosition();
while(l_Index1 != NULL)
{
l_sMapBuffer.GetNextAssoc( l_Index1,l_sSection,l_sValeur);
m_fichier.Write("[",1);
// Copie caractère par caractère
for(l_iIndex=0;l_iIndex<l_sSection.GetLength();l_iIndex++)
{
l_usCaractere=l_sSection.GetAt(l_iIndex);
m_fichier.Write(&l_usCaractere,1);
}
m_fichier.Write("]",1);
m_fichier.Write("\r\n",2);
/// algo : Pour chaques sections
l_Index2=m_mapValeurs.GetStartPosition();
while(l_Index2 != NULL)
{
/// algo : Recherche de chaques clés et valeurs associées à cette section
/// algo : copie dans le fichier
m_mapValeurs.GetNextAssoc(l_Index2,l_sIdentifiant,l_sValeur);
// contenu de l_sKey -> section;clé
l_iPositionVirgule=l_sIdentifiant.Find(';');
/// algo : Si c'est la bonne section
if(l_sSection.Compare(l_sIdentifiant.Left(l_iPositionVirgule))==0)
{
/// algo : écrit la clé et la valeur ds le fic
l_sCle=l_sIdentifiant.Mid(l_iPositionVirgule+1,l_sIdentifiant.GetLength()-1);
// Copie caractère par caractère
for(l_iIndex=0;l_iIndex<l_sCle.GetLength();l_iIndex++)
{
l_usCaractere=l_sCle.GetAt(l_iIndex);
m_fichier.Write(&l_usCaractere,1);
}
m_fichier.Write("=",1);
// Copie caractère par caractère
for(l_iIndex=0;l_iIndex<l_sValeur.GetLength();l_iIndex++)
{
l_usCaractere=l_sValeur.GetAt(l_iIndex);
m_fichier.Write(&l_usCaractere,1);
}
m_fichier.Write("\r\n",2);
}
}
m_fichier.Write("\r\n",2);
}
m_fichier.Close();
}
}
CString BFichierIniPDA::getNomSection()const
{
/// ----------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::getNomSection() -> CString ----------------
/// ----------------------------------------------------------------------------
/// ----- Objectif : Récupérer le nom de la section
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// ----------------------------------------------------------------------------
/// ----- retour (CString) : Nom de la section sans crochets
/// ----------------------------------------------------------------------------
/// ----- Var Utilisées de la classe (1) : m_sSection
/// ----- Var Internes à la fonction (1) : nomSection
/// ----- Var In (1) : m_sSection
CString nomSection=m_sSection;
nomSection.Remove('[');
nomSection.Remove(']');
return(nomSection);
}
int BFichierIniPDA::get(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpDefault,LPTSTR lpReturnedString)const
{
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::get(LPCTSTR lpAppName ,LPCTSTR lpKeyName ,LPCTSTR lpDefault ,LPTSTR lpReturnedString) -> int ----------------
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// ----- Objectif : Lire une chaine dans un fichier de style INI
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// ----- LPCTSTR lpAppName : section
/// ----- LPCTSTR lpKeyName : clef
/// ----- LPCTSTR lpDefault : Valeur par défaut
/// ----- LPTSTR lpReturnedString : Pointeur sur buffer qui va contenir la valeur lue
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// ----- retour (int) : Taille de la chaine lue
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// ----- Var Muettes (cf.partie préc) (4) : lpAppName ,lpDefault ,lpKeyName ,lpReturnedString
/// ----- Var Internes à la fonction (3) : cle ,l_iValeurRetour ,valeur
/// ----- Var Utilisées par adresse (1) : lpReturnedString
/// ----- Var In (3) : lpAppName ,lpDefault ,lpKeyName
/// ----- Var In-Out (1) : lpReturnedString
int l_iValeurRetour=0;
CString cle=lpAppName;
cle+=';';
cle+=lpKeyName;
CString valeur;
if(m_mapValeurs.Lookup(cle,valeur))
{
// on a bien trouvé l'entrée
wcsncpy(lpReturnedString,valeur,valeur.GetLength());
// Ajout du caractère de fin de chaine
lpReturnedString[valeur.GetLength()]='\0';
l_iValeurRetour=valeur.GetLength();
}
else // On n'a pas trouve l'entrée
wcsncpy(lpReturnedString,lpDefault,wcslen(lpDefault));
return(l_iValeurRetour);
}
void BFichierIniPDA::set(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpString)
{
/// -------------------------------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::set(LPCTSTR lpAppName ,LPCTSTR lpKeyName ,LPCTSTR lpString) ----------------
/// -------------------------------------------------------------------------------------------------------------
/// ----- Objectif : Ecrire une chaine dans un fichier de style INI
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// -------------------------------------------------------------------------------------------------------------
/// ----- LPCTSTR lpAppName : section
/// ----- LPCTSTR lpKeyName : clé
/// ----- LPCTSTR lpString : valeur
/// -------------------------------------------------------------------------------------------------------------
/// ----- Var Utilisées de la classe (1) : m_sNomFichier
/// ----- Var Muettes (cf.partie préc) (3) : lpAppName ,lpKeyName ,lpString
/// ----- Var Internes à la fonction (1) : cle
/// ----- Var In (4) : lpAppName ,lpKeyName ,lpString ,m_sNomFichier
CString cle=lpAppName;
cle+=';';
cle+=lpKeyName;
// Inscription d'une nouvelle chaîne ou mise à jour si elle existe déjà
m_mapValeurs.SetAt(cle,lpString);
// Mise à jour du fichier
copyArbre(m_sNomFichier);
}
int BFichierIniPDA::getInt(LPCTSTR lpAppName,LPCTSTR lpKeyName,int nDefault)const
{
/// -------------------------------------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::getInt(LPCTSTR lpAppName ,LPCTSTR lpKeyName ,int nDefault) -> int ----------------
/// -------------------------------------------------------------------------------------------------------------------
/// ----- Objectif : Lire un entier dans un fichier de style INI
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// -------------------------------------------------------------------------------------------------------------------
/// ----- LPCTSTR lpAppName : Nom de la section
/// ----- LPCTSTR lpKeyName : Nom de la clé
/// ----- int nDefault(par défaut : '0') : Valeur par défaut
/// -------------------------------------------------------------------------------------------------------------------
/// ----- retour (int) : Valeur lue
/// -------------------------------------------------------------------------------------------------------------------
/// ----- Var Muettes (cf.partie préc) (3) : lpAppName ,lpKeyName ,nDefault
/// ----- Var Internes à la fonction (3) : cle ,l_iValeurRetour ,valeur
/// ----- Var In (3) : lpAppName ,lpKeyName ,nDefault
int l_iValeurRetour=nDefault;
CString cle=lpAppName;
cle+=';';
cle+=lpKeyName;
CString valeur;
if(m_mapValeurs.Lookup(cle,valeur))
// on a bien trouvé l'entrée
if(!valeur.IsEmpty())
l_iValeurRetour=_tcstol(valeur,NULL,0);
return(l_iValeurRetour);
}
void BFichierIniPDA::setInt(LPCTSTR lpAppName,LPCTSTR lpKeyName,int nValeur)
{
/// -----------------------------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::setInt(LPCTSTR lpAppName ,LPCTSTR lpKeyName ,int nValeur) ----------------
/// -----------------------------------------------------------------------------------------------------------
/// ----- Objectif : Ecrire un entier dans un fichier de style INI
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// -----------------------------------------------------------------------------------------------------------
/// ----- LPCTSTR lpAppName : section
/// ----- LPCTSTR lpKeyName : clé
/// ----- int nValeur : Valeur à écrire
/// -----------------------------------------------------------------------------------------------------------
/// ----- Var Utilisées de la classe (1) : m_sNomFichier
/// ----- Var Muettes (cf.partie préc) (3) : lpAppName ,lpKeyName ,nValeur
/// ----- Var Internes à la fonction (2) : cle ,valeur
/// ----- Var In (4) : lpAppName ,lpKeyName ,m_sNomFichier ,nValeur
CString cle=lpAppName;
cle+=';';
cle+=lpKeyName;
CString valeur;
valeur.Format(_T("%d"),nValeur);
// Inscription d'une nouvelle valeur ou mise à jour si elle existe déjà
m_mapValeurs.SetAt(cle,valeur);
// Mise à jour du fichier
copyArbre(m_sNomFichier);
}
void BFichierIniPDA::delSection(CString p_sSectionSupprime)
{
/// ----------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::delSection(CString p_sSectionSupprime) ----------------
/// ----------------------------------------------------------------------------------------
/// ----- Objectif : Supprimer une section entière
/// ----- Auteur(s) : Magic_Nono 17/01/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// ----------------------------------------------------------------------------------------
/// ----- CString p_sSectionSupprime : Nom de la section à supprimer
/// ----------------------------------------------------------------------------------------
/// ----- Var Utilisées de la classe (1) : m_sNomFichier
/// ----- Var Muettes (cf.partie préc) (1) : p_sSectionSupprime
/// ----- Var Internes à la fonction (4) : l_Position ,l_iIndex ,l_sSection ,l_sValeur
/// ----- Var In (1) : m_sNomFichier
POSITION l_Position;
int l_iIndex;
CString l_sSection;
CString l_sValeur;
l_Position=m_mapValeurs.GetStartPosition();
while(l_Position!=NULL)
{
m_mapValeurs.GetNextAssoc(l_Position,l_sSection,l_sValeur);
// Recherche de la position de la virgule qui sépare la section de la clé
l_iIndex=l_sSection.Find(_T(";"),0);
// Compare la section à supprimer et la section actuelle
if(p_sSectionSupprime.Compare(l_sSection.Left(l_iIndex))==0)
// supprime
m_mapValeurs.RemoveKey(l_sSection);
}
copyArbre(m_sNomFichier);
}
bool BFichierIniPDA::isVide()const
{
/// ------------------------------------------------------------------
/// ---------------- BFichierIniPDA::isVide() -> bool ----------------
/// ------------------------------------------------------------------
/// ----- Objectif : fichier vide?
/// ----- Auteur(s) : Magic_Nono 10/02/05
/// ----- PreCond : /
/// ----- PostCond : /
/// ----- Etat : 1 (-1<0<1<2)
/// ------------------------------------------------------------------
/// ----- retour (bool) : cf.objectif
/// ------------------------------------------------------------------
/// ----- Var Utilisées de la classe (1) : m_tailleArbre
/// ----- Var In (1) : m_tailleArbre
return(0==m_tailleArbre);
}
Magic Nono: l'informagicien!
alkove
Messages postés
37
Date d'inscription
jeudi 27 mars 2003
Statut
Membre
Dernière intervention
6 mai 2005
14 févr. 2005 à 15:17
14 févr. 2005 à 15:17
Renvoi toute les sections du fichier ini
DWORD GetPrivateProfileSectionNames(
LPTSTR lpszReturnBuffer, // address of return buffer
DWORD nSize, // size of return buffer
LPCTSTR lpFileName // address of initialization filename
);
Renvoi toute les clefs de la section spécifiée
DWORD GetPrivateProfileSectionNames(
LPTSTR lpszReturnBuffer, // address of return buffer
DWORD nSize, // size of return buffer
LPCTSTR lpFileName // address of initialization filename
);
DWORD GetPrivateProfileSectionNames(
LPTSTR lpszReturnBuffer, // address of return buffer
DWORD nSize, // size of return buffer
LPCTSTR lpFileName // address of initialization filename
);
Renvoi toute les clefs de la section spécifiée
DWORD GetPrivateProfileSectionNames(
LPTSTR lpszReturnBuffer, // address of return buffer
DWORD nSize, // size of return buffer
LPCTSTR lpFileName // address of initialization filename
);
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
manta7
Messages postés
105
Date d'inscription
samedi 25 janvier 2003
Statut
Membre
Dernière intervention
13 décembre 2008
14 févr. 2005 à 21:17
14 févr. 2005 à 21:17
Oki alkove c'est ce que je cherchais mais après je ne sais pas m'en servir de ton code....
alkove
Messages postés
37
Date d'inscription
jeudi 27 mars 2003
Statut
Membre
Dernière intervention
6 mai 2005
15 févr. 2005 à 00:08
15 févr. 2005 à 00:08
me suis trompé pour la deuxième fonction c'est
DWORD GetPrivateProfileSection(
LPCTSTR lpAppName,
LPTSTR lpReturnedString,
DWORD nSize,
LPCTSTR lpFileName
);
en fait ces fonctions retournes une chaine de caractère dans laquel
sont les réponsses séparrées par des caractères null, et a la fin de la
chaine il y a deux caractères null
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/getprivateprofilesection.asp
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/getprivateprofilesectionnames.asp
DWORD GetPrivateProfileSection(
LPCTSTR lpAppName,
LPTSTR lpReturnedString,
DWORD nSize,
LPCTSTR lpFileName
);
en fait ces fonctions retournes une chaine de caractère dans laquel
sont les réponsses séparrées par des caractères null, et a la fin de la
chaine il y a deux caractères null
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/getprivateprofilesection.asp
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/getprivateprofilesectionnames.asp
magic_Nono
Messages postés
1878
Date d'inscription
jeudi 16 octobre 2003
Statut
Membre
Dernière intervention
16 mars 2011
15 févr. 2005 à 08:16
15 févr. 2005 à 08:16
ok les gars
mais pourquoi faire simple?
autant tout gérer, cela explique vraiement la philosophie
ensuite, on peut jouer avec des lib
et là seulement, on les exploite au mieux.
sinon, ben bien Alkove ... je ne connaissais pas ces fonctions
Magicalement
Nono: l'informagicien!
mais pourquoi faire simple?
autant tout gérer, cela explique vraiement la philosophie
ensuite, on peut jouer avec des lib
et là seulement, on les exploite au mieux.
sinon, ben bien Alkove ... je ne connaissais pas ces fonctions
Magicalement
Nono: l'informagicien!
alkove
Messages postés
37
Date d'inscription
jeudi 27 mars 2003
Statut
Membre
Dernière intervention
6 mai 2005
15 févr. 2005 à 08:31
15 févr. 2005 à 08:31
je suis d'accord pour tout gèrer, mais bon, là c'est réinventer la roue ;)
