Base de données fichier
Description
LOGICIEL COMPILE AVEC BC++ 5 STANDARD
Ce logiciel genere une base de données des fichiers listés dans un dossier ou lecteur par la suite on peut faire une comparaison avec un autre lecteur ou dossier.
Si l'on passe du CD-ROM au DVD-ROM alors il est interessant de faire une base des DVD-ROM pour la comparer au CD-ROM pour vérifier que tous les fichiers sont sauvegardés.
Ce logiciel genere une base de données des fichiers listés dans un dossier ou lecteur par la suite on peut faire une comparaison avec un autre lecteur ou dossier.
Source / Exemple :
// Aujourd'hui le programme est sur le point d'être fini:
//L'optimisation est réalisé sur toutes les bases de donnéees
//On peut effectuer une autre comparaison après en avoir déjà
//effectué une.
//
//---------------------------------------------------------------------------
//------------------------Partie glipper-------------------------------------
int nbdossier = 0;
int nbdossiertotal = 0;
int ColumnToSort = 0;
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <winbase.h>
#include <iostream>
#include <fstream>
#include <string>
#include <string.h>
#include <condefs.h>
#include <Unit1.h>
#include <sstream>
#include <ctype.h>
#include <list.h>
//#include <Unit2.h>
bool ordre0 = 0,ordre1 = 0,ordre2 = 0,ordre3 = 0,ordre4 = 0, ordre5 =0;
//********pour lecture nom du volume********************
const int Max_Length = 256;
char * VolName = new char[Max_Length];
char * FileSysName = new char[Max_Length];
unsigned long VolSerial;
unsigned long FileMaxLen;
unsigned long FileFlags;
AnsiString Message;
//********fin lecture nom du volume*********************
//fonctions pour le listage
void listagedelaselection(char *CurrentDir, FILE* f);
void nombrededossier(char *CurrentDir);
void listagedossier(char *CurrentDir,int nombre,int x, FILE* f);
void Save_En_Tete_Fichier(FILE* f, char *Chemin);
void inscriptionzip(FILE* f,char *S,char *nomdufichier);
char Indentation[256] = ""; // sert à indenter dans le fichier texte
//fonctions pour la comparaison de la selection a la base de donnees
void remplirtableau(char *CurrentDir);
FILE* dossierdoublon;
FILE* dossiernomdifferent;
FILE* dossieressai;
FILE* dossieressaibis;
FILE* dossierlist;
FILE* supzip;
FILE *a;
int i,k;
int fichier;
int fichiertotal;
char *Texte;
unsigned long int Taille;
_FILETIME creation;
#include <vcl.h>
#pragma hdrstop
#include <FileCtrl.hpp>
//#include "Unit1.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
int lignetableau = 0;
int lignetableaubis = 0;
int ligne=0;
int ligne2 = 0;
int lignebis=0;
char mot[500];
char motbis[500];
int nbfichiertotal = 0;
int nbfichierdifferent = 0;
int nbfichieridentique = 0;
int cliqueb2 = 0;
//essai struct
//******************************************************************************
//******************************************************************************
using namespace std;
typedef struct Structure Sine;
struct Structure //structure qui ne sert à rien :p
{
public:
int test;
string texte;
string fichierbase;
string cheminfichier;
string taillefichier;
string datefichier;
string heurefichier;
string temporaire;
};
//fin essai struct
//******************************************************************************
//******************************************************************************
//essai seconde struct
//******************************************************************************
//******************************************************************************
typedef struct Structurebis Sinebis;
struct Structurebis //structure qui ne sert à rien :p
{
public:
int testbis;
string textebis;
string fichierbasebis;
string cheminfichierbis;
string taillefichierbis;
string datefichierbis;
string heurefichierbis;
string temporairebis;
};
//fin essai seconde struct
//******************************************************************************
//******************************************************************************
//essai LISTE DOUBLEMENT CHAINEE
//******************************************************************************
//******************************************************************************
class Chose
{
public:
/* indice de l'objet */
int listcounter;
/* pointeurs sur instances suivante et précédente */
Chose *pSuiv, *pPrec;
};
Chose *pPrem=NULL, *pDern=NULL;
//fin essai LISTE DOUBLEMENT CHAINEE
//******************************************************************************
//******************************************************************************
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
Edit1->Visible = false;
Edit2->Visible = false;
Edit3->Visible = false;
Edit4->Visible = false;
Edit6->Visible = false;
Label1->Visible = false;
Label2->Visible = false;
Label3->Visible = false;
Label4->Visible = false;
Label8->Visible = false;
Button3->Visible = false;
DeleteFile("C:\\pouressai\\fichierzip.bat");
DeleteFile("C:\\pouressai\\supzip.bat");
DeleteFile("C:\\pouressai\\fichieressai.xrdb");
DeleteFile("C:\\pouressai\\fichieressaibis.xrdb");
DeleteFile("C:\\pouressai\\fichierhorsdelabase.xrdb");
DeleteFile("C:\\pouressai\\fichiertemporaire.txt");
DeleteFile("C:\\pouressai\\fichierdoublon.xrdb");
system ("md c:\\pouressai");
ListView1->Visible = false;
Form1->ProgressBar1->Visible = False;
}
//fonction pour la selection du listage d'un dossier ou lecteur
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Form1->ListView1->Visible = false;
Form1->Label1->Visible = false;
Form1->Label2->Visible = false;
Form1->Label3->Visible = false;
Form1->Label4->Visible = false;
Form1->Label8->Visible = false;
Form1->Edit1->Visible = false;
Form1->Edit2->Visible = false;
Form1->Edit3->Visible = false;
Form1->Edit4->Visible = false;
Form1->Edit6->Visible = false;
nbdossier = 0;
AnsiString S;
S = "";
if (SelectDirectory("Selection du dossier a scanner", "", S))
ComboBox1->Text = S;
if (OpenDialog1->Execute()){
AnsiString NomFic;
NomFic = OpenDialog1->FileName;
ComboBox2->Text = NomFic;
}
FILE *f;
f = fopen(OpenDialog1->FileName.c_str(),"a");
if (f == NULL)
{
MessageBox(NULL,"Erreur lors de l'ouverture du fichier","Impossible d'ouvrir le dossier", MB_ICONSTOP);
return ;
}
else
{
MessageBox(NULL,"Début du listage","Tous les fichiers vont être listés", MB_ICONSTOP);
fichier = 0;
fichiertotal = 0;
Save_En_Tete_Fichier(f,ComboBox1->Text.c_str());
i=0;
listagedelaselection(ComboBox1->Text.c_str(), f);
nombrededossier(ComboBox1->Text.c_str());
k=0;
char nombredossier[256];
sprintf(nombredossier, "%d", i);
nbdossiertotal = i;
// MessageBox(NULL,nombredossier,"nombre de dossier", MB_ICONINFORMATION);
listagedossier(ComboBox1->Text.c_str(),i,0, f);
char nombrefichier[256];
sprintf(nombrefichier, "%d", fichiertotal);
// MessageBox(NULL,nombrefichier,"nombre de fichiers", MB_ICONINFORMATION);
fclose(f);
MessageBox(NULL,"pour information","Tous les fichiers sont listés", MB_ICONSTOP);
}
return ;
}
//********************************************************************************************************
//********************************************************************************************************
//fonction qui permet de d'écrire l'entête du fichier base de données
void Save_En_Tete_Fichier(FILE* f, char *S)
{
//*************information nom du volume*********************************************
AnsiString essainomvolume = S; // copy to AnsiString
char szTmp2[256];
sprintf(szTmp2, "%s",essainomvolume);
//MessageBox(NULL,szTmp2,"chemin du volume a lister",MB_ICONSTOP);
fichier = 0;
//char nomvolume[256] = "";
if(essainomvolume.IsPathDelimiter(essainomvolume.Length()))
{
//sprintf (S, "%s*.*", CurrentDir);
//else
//{
//sprintf (S, "%s\\*.*", CurrentDir);
//}
// char SysFile[16];
//if (GetVolumeInformationA(S, VolName, Max_Length, &VolSerial, &FileMaxLen, &FileFlags, FileSysName, Max_Length))
if (GetVolumeInformationA(S,VolName, NULL,NULL, NULL, NULL, NULL, NULL))
{
//AnsiString Message = "Nom du disque : " + AnsiString(VolName);
//Message = "Nom du disque : " + AnsiString(VolName);
//Message = AnsiString(VolName);
//Message = String(VolName);
//sprintf(szTmp2,"!%s",Message);
// Message += "\nSystème de fichiers : " + AnsiString(FileSysName);
// Message += "\nNuméro de série : " + FloatToStr(VolSerial);
// ShowMessage(Message);
}
}
//delete[] VolName;
//delete[] FileSysName;
// sprintf(nomvolume,"%s",Message);
Texte = (char*) malloc((90+strlen(S))*sizeof(char)+1);
strcpy(Texte, "|Repertoire en cours : ");
strcat(Texte, S);
//strcat(Texte, szTmp2);
//strcat(Texte, VolName);
//strcat(Texte, nomvolume);
strcat(Texte, "\n");
strcat(Texte, "|--------------------------------------");
strcat(Texte, "\n|\n");
strcat(Texte, "|Fichiers présents : \n|\n");
fwrite(Texte, sizeof(char), strlen(Texte), f);
free(Texte);
AnsiString VolName2 = VolName;
//fprintf (f,"|\n|\n|pour essai nom fichier Repertoire en cours: %s\n",VolName2);
fprintf (f,"|\n|\n|pour essai nom fichier Repertoire en cours: %s\n",szTmp2);
}
//********************************************************************************************************
//********************************************************************************************************
//compte le nombre de dossier afin d'établir un tableau contenant tout les noms des dossiers
void nombrededossier(char *CurrentDir)
{
char S[256];
HANDLE listing;
WIN32_FIND_DATA wData;
sprintf (S, "%s\\*.*", CurrentDir);
listing = FindFirstFile(S, &wData);
sprintf (S, "%s", CurrentDir);
if (listing != INVALID_HANDLE_VALUE)
{
do
{
if ((strcmp(wData.cFileName, ".."))&&((strcmp(wData.cFileName, "."))))
{
if (wData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
i=i+1;
sprintf(S, "%s\\%s", CurrentDir, wData.cFileName);
strcat(Indentation, " | ");
nombrededossier(S);
Indentation[strlen(Indentation)-4] = '\0';
int j = strlen(S)-2;
while (j>0)
{
if (S[j] == '/')
{
S[j+1] = '\0';
break;
}
j--;
}
}
}
}while (FindNextFile(listing, &wData));
}
FindClose(listing);
}
//********************************************************************************************************
//********************************************************************************************************
void listagedelaselection(char *CurrentDir, FILE *f)
{
HANDLE listing;
WIN32_FIND_DATA wData;
char S[256];
char A[256];
AnsiString szExeDir2 = CurrentDir; // copy to AnsiString
char szTmp2[256];
sprintf(szTmp2, "%s",szExeDir2);
fichier = 0;
// est-ce un lecteur ou un dossier
if(szExeDir2.IsPathDelimiter(szExeDir2.Length()))
{
//c'est un lecteur
sprintf (S, "%s*.*", CurrentDir);
}
//c'est un dossier
else
{
sprintf (S, "%s\\*.*", CurrentDir);
}
//recherde des fichiers
listing = FindFirstFile(S, &wData);
sprintf (S, "%s", CurrentDir);
if (listing != INVALID_HANDLE_VALUE)
{
do
{
//verifie si c'est un dossier ou un fichier
if ((strcmp(wData.cFileName, ".."))&&((strcmp(wData.cFileName, "."))))
{
if (wData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
}
else
{
//recherche de l'extension du fichier
AnsiString MyFilesExtension = ExtractFileExt(wData.cFileName);
char extension[256];
sprintf (extension, "%s",MyFilesExtension);
if ((!strcmp(extension, ".zip")))
{
//FILE *a;
sprintf (A, "%s\\%s", CurrentDir,wData.cFileName);
a = fopen("c:\\pouressai\\fichierzip.bat","wt");
int ziplong = strlen(A);
char zip[256];
sprintf(zip, "%d",ziplong);
AnsiString danszip = A;
int espace = 0;
espace = danszip.AnsiPos(" ");
char zipbis[256];
sprintf(zipbis, "%d",espace);
if (espace > 0)
danszip = "\"" + danszip + "\"";
//La ligne suivante est a garder le reste ???
fprintf (a, "c:\\sevenzip\\7za.exe l %s >>c:\\pouressai\\fichierzipbis.txt",danszip);
//execute la commande de listing du fichier zip
system ("c:\\pouressai\\fichierzip.bat");
// CmdShow;
}
fichier++;
fichiertotal++;
Form1->Edit5->Visible = true;
Form1->Label7->Visible = true;
Form1->Edit5->Text = IntToStr(fichiertotal);
Application->ProcessMessages();
;unsigned int Taille;
Taille = (wData.nFileSizeLow & 0xFFFFFFFF);
char poids[256];
sprintf(poids, "%d", Taille);
SYSTEMTIME sttm;
//char buf[20];
char buf[9]="";
//char buf2[16];
char tuf[4]="";
char nomdufichier[256];
sprintf(nomdufichier, "%s",wData.cFileName);
FileTimeToLocalFileTime(&wData.ftLastWriteTime, &creation);
FileTimeToSystemTime(&creation, &sttm);
GetDateFormat(0, 0, &sttm, "dd/MM/yyyy", buf, 11);
//GetDateFormat(0, 0, &sttm, "dd/MM/yyyy", buf, 20);
fprintf (f, "%s;%s;%s;%s;",S,wData.cFileName,poids,buf); // on enregistre le nom du fichier
GetTimeFormat(0, 0, &sttm, "HH:mm", tuf, 6);
//GetTimeFormat(0, 0, &sttm, "hh:mm", tuf, 6);
fprintf (f, "%s\n",tuf); // on enregistre le nom du fichier
//GetTimeFormat(0, 0, &sttm, "HH:mm", buf2, 16);
//fprintf (f, "%s\t%s\t%s\t%s\t%s\n",S,wData.cFileName,poids,buf,buf2); // on enregistre le nom du fichier
//fprintf (f, "%s;%s;%s;%s\n",S,wData.cFileName,poids,buf); // on enregistre le nom du fichier
FILE *w;
//appel la fonction inscription zip
inscriptionzip(f,S,nomdufichier);
{
}
}
}
}while (FindNextFile(listing, &wData));
}
char nbfichier[256];
// sprintf(nbfichier, "%d", fichier);
// fprintf (f, "|%s\n",nbfichier); // on enregistre le nombre de fichierfichier
FindClose(listing);
}
//********************************************************************************************************
//remise en forme du fichier fichierzipbis.txt
//********************************************************************************************************
void inscriptionzip(FILE* f,char *S,char *nomdufichier)
{
char buff[255];
char longueur[4];
char file[1000] = " ";
//int posslash = 0;
char nouveaunomfichier[1000] = " ";
ifstream infile ("c:\\pouressai\\fichierzipbis.txt");
if (!infile) return;
while (!infile.eof())
{
char buff[255];
infile.getline(buff,sizeof(buff));
//MessageBox(NULL,"a la ligne",buff,MB_ICONINFORMATION);
//int pourquoipas = StrComp(buff,"Errors: 1");
//int pourquoipas = strcmp(buff,"Errors: 1");
//if (buff == "Errors: 1") goto pasbon;
if (buff[0] == 'E' && buff[1] == 'r' && buff[2] == 'r' && buff[3] == 'o' && buff[4] == 'r') goto pasbon;
if ((buff[0] == '1') || (buff[0] == '2'))
{
fichiertotal++;
Form1->Edit5->Text = IntToStr(fichiertotal);
Application->ProcessMessages();
char date[9] = "";
for (int b = 0;b<10;b++)
{
date[b] = buff[b];
}
char datemodifie[12] = "";
datemodifie[0] = date [8];
datemodifie[1] = date [9];
datemodifie[2] = '/';
datemodifie[3] = date [5];
datemodifie[4] = date [6];
datemodifie[5] = '/';
datemodifie[6] = date [0];
datemodifie[7] = date [1];
datemodifie[8] = date [2];
datemodifie[9] = date [3];
char heure[4]="";
for (int b = 0;b<5;b++)
{
heure[b] = buff[b+11];
}
//27072007
AnsiString taillest;
char taille[16]="";
for (int b=0;b<15;b++)
{
taille[b] = buff[b+25];
}
//27072007
taillest = taille;
int essaitaille =0;
essaitaille = taillest.AnsiPos(" ");
while (essaitaille == 1)
{
if (essaitaille == 1)
{
taillest = taillest.Delete(1,1);
}
essaitaille = taillest.AnsiPos(" ");
}
//ShowMessage(essaitaille);
//MessageBox(NULL,taillest.c_str(),"apercu de la taille du zip",MB_ICONSTOP);
essaitaille = taillest.AnsiPos(" ");
while (essaitaille > 0)
{
taillest = taillest.Delete(essaitaille,essaitaille);
essaitaille = taillest.AnsiPos(" ");
}
AnsiString nomparansistring = buff;
nomparansistring.Delete (1,53);
char apercustring[1000];
sprintf(apercustring,"%s",nomparansistring);
//MessageBox(NULL,apercustring,"apercu nom zip du buff par ansistring",MB_ICONSTOP);
int guillemet;
guillemet = nomparansistring.AnsiPos("\\");
while (guillemet > 0)
{
nomparansistring.Delete (1,guillemet),
guillemet = nomparansistring.AnsiPos("\\");
}
sprintf(apercustring,"%s",nomparansistring);
//MessageBox(NULL,apercustring,"apercu nom zip du buff par ansistring sans antislash",MB_ICONSTOP);
//modification le 27052007 pour prendre en compte les fichiers zip
//fprintf (f, "|%s\t%s\t%s\t%s\n",apercustring,taille,datemodifie,heure); // on enregistre le nom du fichier
//fprintf (f,"fichierzip%s\\%s;%s;%s;%s;%s;\n",S,nomdufichier,apercustring,taillest.c_str(),datemodifie,heure); // on enregistre le nom du fichier
fprintf (f,"%s\\%s;%s;%s;%s;%s;\n",S,nomdufichier,apercustring,taillest.c_str(),datemodifie,heure); // on enregistre le nom du fichier
file=="";
char vidage[1000]="";
strcpy (nouveaunomfichier,vidage);
strcpy (file,vidage);
taille=="";
date=="";
heure=="";
char vidbuff[255]="";
strcpy (buff,vidbuff);
}
}
infile.close();
fclose(a);
system ("del c:\\pouressai\\fichierzipbis.txt");
return;
pasbon:
//MessageBox(NULL,"Le voici le fichier illisible",S,MB_ICONSTOP);
fprintf (f,"%s\\%s;*****FICHIERZIPHS******;;;;\n",S,nomdufichier); // on enregistre le nom du fichier
infile.close();
fclose(a);
system ("del c:\\pouressai\\fichierzipbis.txt");
}
//********************************************************************************************************
//********************************************************************************************************
void listagedossier(char *CurrentDir,int i,int x,FILE* f)
{
nbdossier++;
char testi[256];
sprintf(testi, "%d", i);
char testx[256];
sprintf(testx, "%d", x);
char nombre[256];
sprintf(nombre, "%d", i);
char **data;
data = new char*[256]; // ETAPE 1: INITIALISE LES LIGNES.
data[x] = new char[i]; // ETAPE 2: INITIALISE LES COLONNES.
HANDLE listing;
WIN32_FIND_DATA wData;
char S[256];
char Z[256];
sprintf (S, "%s", CurrentDir);
AnsiString szExeDir = CurrentDir; // copy to AnsiString
if(szExeDir.IsPathDelimiter(szExeDir.Length())) // ensure backslash - now program can run from disk root directory
{
sprintf (S, "%s*.*", CurrentDir);
}
else
{
sprintf (S, "%s\\*.*", CurrentDir);
}
listing = FindFirstFile(S, &wData);
sprintf (S, "%s", CurrentDir);
if (listing != INVALID_HANDLE_VALUE)
{
do
{
if ((strcmp(wData.cFileName, ".."))&&((strcmp(wData.cFileName, "."))))
{
if (wData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
AnsiString szExeDir = CurrentDir;
if(szExeDir.IsPathDelimiter(szExeDir.Length())) // ensure backslash - now program can run from disk root directory
{
sprintf(S, "%s%s", CurrentDir, wData.cFileName);
}
else
{
sprintf(S, "%s\\%s", CurrentDir, wData.cFileName);
}
char pointeur[256];
sprintf (pointeur, "%d", x);
data[x] = S; // ETAPE 2: INITIALISE LES COLONNES
sprintf(Z, "%s", data[x]);
x++;
listagedelaselection(Z,f);
strcat(Indentation, " | ");
listagedossier(S,0,x,f);
Indentation[strlen(Indentation)-4] = '\0';
int j = strlen(S)-2;
k=k+1;
Form1->ProgressBar1->Visible = true;
Form1->ProgressBar1->Min = 0;
Form1->ProgressBar1->Max = nbdossiertotal;
Form1->ProgressBar1->Position = nbdossier;
Application->ProcessMessages();
while (j>0)
{
if (S[j] == '/')
{
S[j+1] = '\0';
break;
}
j--;
}
}
}
}while (FindNextFile(listing, &wData));
}
FindClose(listing);
delete [] data;
Form1->ProgressBar1->Visible = false;
}
//********************************************************************************************************
//********************************************************************************************************
// Comparaison du fichier avec un lecteur ou dossier ********************************
//***********************************************************************************
void __fastcall TForm1::Button2Click(TObject *Sender)
{
fichiertotal = 0;
Form1->Edit5->Visible = false;
Form1->Label7->Visible = false;
DeleteFile("C:\\pouressai\\fichiertemporaire.txt");
cliqueb2++;
int nbli = Form1->ListView1->Items->Count;
//ShowMessage(nbli);
for (int nbli3=0;nbli3 < nbli;nbli3++)
{
//Form1->ListView1->Items->Delete(nbli3);
Form1->ListView1->Items->Delete(0);
}
char basedonnees[500];
//selection de la base de données de référence selectionnée en premier
if (OpenDialog1->Execute()){
AnsiString NomFic;
NomFic = OpenDialog1->FileName;
ComboBox2->Text = NomFic;
sprintf(basedonnees,"%s",NomFic);
}
AnsiString S;
S = "";
if (SelectDirectory("Selection du lecteur à scanner", "", S))
ComboBox1->Text = S;
ifstream infile2 (basedonnees);
if (!infile2) return;
string line;
int start0 = GetTickCount();
while (getline( infile2, line ))
{
++ligne;
}
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "\n*****************nombre de ligne comptées dans la base de référence: %d *****************\n",ligne);
//fclose(dossieressaibis);
//listage dossier ou lecteur selectionné
//*****************************************************************************
//*****************************************************************************
//dans le fichier seconddossier sera ecrit les informations relatives
//au dossier ou lecteur selectionné pour listage (c:\fichiertemporaire.txt).
FILE* seconddossier;
seconddossier = fopen("c:\\pouressai\\fichiertemporaire.txt","a");
//appel a la fonction de listage du dossier ou lecteur selectionné et
//inscrit les données dans c:\pouressai\fichiertemporaire.txt
int start,stop;
start = GetTickCount();
Form1->Label9->Visible = true;
Form1->Label9->Caption = "Listage dossier séléctionné en cours:";
listagedelaselection(ComboBox1->Text.c_str(), seconddossier);
//calcul du nombre de dossier dans le dossier ou lecteur selectionné pour listage
nombrededossier(ComboBox1->Text.c_str());
k=0;
char nombredossier[256];
sprintf(nombredossier, "%d", i);
//affiche le nombre de dossier dans le dossier ou lecteur selectionné
// MessageBox(NULL,nombredossier,"nombre de dossier du dossier ou lecteur selectionné", MB_ICONINFORMATION);
//appel de la fonction listage pour lister les fichiers dans le lecteur ou dossier
listagedossier(ComboBox1->Text.c_str(),i,0, seconddossier);
//fermeture du fichier (c:\fichiertemporaire.txt)
stop = (GetTickCount() - start)/1000;
char temps[150];
sprintf(temps,"Listage dossier séléctionné terminé en : %d s",stop);
Form1->Label9->Caption = temps;
fclose(seconddossier);
//fin listage dossier ou lecteur selectionné
//***************remplisage dossier ok ****************************************
//*****************************************************************************
//lecture base de donnée texte ainsi que c:\pouressai\fichiertemporaire.txt
//*****************************************************************************
//*****************************************************************************
//Form2->Visible = true;
//Application->ProcessMessages();
remplirtableau(OpenDialog1->FileName.c_str());
//fin lecture base de donnée texte ainsi que c:\fichiertemporaire.txt
//*****************************************************************************
//*****************************************************************************
int stop0 = (GetTickCount()- start0)/1000;
char temps0[150];
sprintf(temps0,"Temps d'execution total: %d s",stop0);
Form1->Label16->Visible = true;
Form1->Label16->Caption = temps0;
return;
}
//******************************************************************************
//******************************************************************************
//******************************************************************************
//fonction qui crée le un element de la liste doublement chainée
void Quelconque(int n)
{
Chose *pC, *pM;
pC=pPrem;
while(pC)
{
pM=pC;
pC=pC->pSuiv;
}
pDern=new Chose();
pM->pSuiv=pDern;
//pM->pSuiv->listcounter=n;
pM->pSuiv->pSuiv=NULL;
pM->pSuiv->pPrec=pM;
}
// -------------------------------------
//******************************************************************************
//******************************************************************************
//******************************************************************************
//fonction qui crée le premier element de la liste doublement chainée
void Premier(int n)
{
pPrem=new Chose();
//pPrem->listcounter=;
pPrem->pSuiv=NULL;
pPrem->pPrec=NULL;
}
//******************************************************************************
//******************************************************************************
//******************************************************************************
//fonction qui fait la liste doublement chainée
void Creation(int n)
{
if(pPrem) Quelconque(n); else Premier(n);
}
//******************************************************************************
//******************************************************************************
//******************************************************************************
//fonction qui affiche dans un fichier texte la liste doublement chainée
//void AffListeAvant(void)
//{
//Chose *pC;
//pC=pPrem;
//while(pC)
// {
// dossierlist = fopen("c:\\pouressai\\fichierlist.xrdb","a");
//char lire3[120];
// sprintf(lire3,"%d", structure[pC->listcounter].fichierbase.c_str());
// fprintf (dossierlist, "%s\t\n",lire3);
// MessageBox(NULL,"ESSAI","élément double list",MB_ICONSTOP);
// ShowMessage(pC->listcounter);
//cout<<pC->i<<" ";
// pC=pC->pSuiv;
// }
//cout<<" ok"<<endl;
//}
//******************************************************************************
//******************************************************************************
//******************************************************************************
//fonction qui fait le tableau dynamique pour la selection et la base de donnees
void remplirtableau(char *CurrentDir)
{
lignebis = 0;
lignetableau = 0;
//comptage ligne de c:\\fichiertemporaire.txt
char basedonneesbis[500];
int I,J,K,L;
sprintf(basedonneesbis,"%s","c:\\pouressai\\fichiertemporaire.txt");
ifstream infile3 (basedonneesbis);
if (!infile3) return;
string line2;
while (getline( infile3, line2 ))
{
if (line2[0] != '|') ++lignebis;
}
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "\n*****************nombre de ligne comptées dans la base du lecteur séléctionné: %d *****************\n",lignebis);
//fclose(dossieressaibis);
//nombre de ligne dans la base de données
//ShowMessage(ligne);
//nombre de ligne dans la selection
//ShowMessage(lignebis);
//creation et initialisation des tableau ou seront mis les données de la base de
//données reference essai struct
//******************************************************************************
//******************************************************************************
int start = GetTickCount();
Form1->Label10->Visible = true;
Form1->Label10->Caption = "Création base de données de la base de données séléctionnées en cours";
Sine* structure = NULL; //On initialise le pointeur sur la Structure à NULL
// int n = 10; //Valeur prise au hasard pour les besoins du problème
// structure = new Sine[n]; //On fait pointer structure sur un tableau de n Structures
structure = new Sine[ligne]; //On fait pointer structure sur un tableau de n Structures
//création de la base issue de la base de données selectionnée (.xrdb)
for(int i=0;i<ligne;i++){ //Boucle-test
structure[i].test = i; //Changement de la valeur du int
// structure[i].texte = "C'est bon !"; //Changement de celle du string
structure[i].texte = ""; //Changement de celle du string
// structure[i].fichierbase = "pour verification";
structure[i].fichierbase = "";
structure[i].cheminfichier = "";
structure[i].taillefichier = "";
structure[i].datefichier = "";
structure[i].heurefichier = "";
}
int stop = (GetTickCount() - start)/1000;
char temps2[150];
sprintf(temps2,"Création base de données de la base de données séléctionnées terminé en : %d s",stop);
Form1->Label10->Caption = temps2;
//Form1->Image1->Visible = true;
//Form1->Image1->Picture->LoadFromFile("D:\\base1_listeebis.bmp");
//Application->ProcessMessages();
//MessageBox(NULL,"structure de la base de données de référence terminée","base de données de référence structurée en attente des éléments",MB_ICONSTOP);
structure[0].temporaire = "";
int start2 = GetTickCount();
Form1->Label11->Visible = true;
Form1->Label11->Caption = "Remplissage de la base de données de la base de données séléctionnées en cours";
Application->ProcessMessages();
int lignedix = 0;
//lecture de la base de données sélectionnée
ifstream infile (CurrentDir);
if (!infile) return;
while (!infile.eof())
{
infile.getline(mot,sizeof(mot));
//MessageBox(NULL,mot,"ligne lu",MB_ICONSTOP);
//separation des elements dans les lignes
//si le debut de la ligne du fichier de la base de donnée ne commence pas par !
//alors on recupere les éléments un par un
//if (mot[0] != '|')
if (mot[0] != '|' && motbis != NULL)
{
lignedix++;
Form1->Edit6->Visible = true;
Form1->Label8->Visible = true;
Form1->Edit6->Text = IntToStr(lignedix);
Application->ProcessMessages();
AnsiString baseligne = mot;
int longueurligne = StrLen(mot);
int baseguillemet = 0;
baseguillemet = baseligne.AnsiPos(";");
AnsiString basecheminfichier2 = baseligne;
basecheminfichier2 = basecheminfichier2.Delete(baseguillemet,longueurligne);
char apercustring[500];
sprintf(apercustring,"%s",basecheminfichier2);
//isolement nom fichier
baseligne = baseligne.Delete(1,baseguillemet);
baseguillemet = baseligne.AnsiPos(";");
AnsiString basenomfichier2 = baseligne;
basecheminfichier2 = basenomfichier2.Delete(baseguillemet,longueurligne);
char apercunomfichier[256];
sprintf(apercunomfichier,"%s",basenomfichier2);
structure[lignetableau].fichierbase = apercunomfichier;
//MessageBox(NULL,structure[lignetableau].fichierbase.c_str(),"fichier isolé la structure",MB_ICONSTOP);
//isolement de la taille du fichier
baseligne = baseligne.Delete(1,baseguillemet);
baseguillemet = baseligne.AnsiPos(";");
AnsiString basetaillefichier2 = baseligne;
basecheminfichier2 = basetaillefichier2.Delete(baseguillemet,longueurligne);
char apercutaillefichier[20];
sprintf(apercutaillefichier,"%s",basetaillefichier2);
structure[lignetableau].taillefichier = apercutaillefichier;
//MessageBox(NULL,structure[lignetableau].taillefichier.c_str(),"verif taille fichier version 1",MB_ICONSTOP);
//isolement date du fichier
baseligne = baseligne.Delete(1,baseguillemet);
baseguillemet = baseligne.AnsiPos(";");
AnsiString basedatefichier2 = baseligne;
basecheminfichier2 = basedatefichier2.Delete(baseguillemet,longueurligne);
char apercudatefichier[20];
char apercudatefichierinverse[20];
sprintf(apercudatefichier,"%s",basedatefichier2);
sprintf(apercudatefichierinverse,"%s",basedatefichier2);
apercudatefichier[0] = apercudatefichierinverse[6];
apercudatefichier[1] = apercudatefichierinverse[7];
apercudatefichier[2] = apercudatefichierinverse[8];
apercudatefichier[3] = apercudatefichierinverse[9];
apercudatefichier[4] ='/';
apercudatefichier[5] = apercudatefichierinverse[3];
apercudatefichier[6] = apercudatefichierinverse[4];
apercudatefichier[7] ='/';
apercudatefichier[8] = apercudatefichierinverse[0];
apercudatefichier[9] = apercudatefichierinverse[1];
//******rajouter pour inverser la date******
//for (int inversedate = 0;inversedate<10;inversedate++)
//{
//apercudatefichier[inversedate+10]=apercudatefichier[inversedate];
//}
//for (int inversedate1 = 0;inversedate1<4;inversedate1++)
//{
//apercudatefichier[inversedate1]=apercudatefichier[inversedate1+16];
//}
//apercudatefichier[4] ='/';
//for (int inversedate1 = 5;inversedate1<7;inversedate1++)
//{
//apercudatefichier[inversedate1]=apercudatefichier[inversedate1+8];
//}
//apercudatefichier[7] ='/';
//for (int inversedate1 = 8;inversedate1<10;inversedate1++)
//{
//apercudatefichier[inversedate1]=apercudatefichier[inversedate1+2];
//}
//for (int coupure=10;coupure<=20;coupure++)
//{
//apercudatefichier[coupure]= ' ';
//}
//******fin rajouter pour inverser la date******
structure[lignetableau].datefichier = apercudatefichier;
//isolement de l'heure du fichier
baseligne = baseligne.Delete(1,baseguillemet);
baseguillemet = baseligne.AnsiPos(";");
AnsiString baseheurefichier2 = baseligne;
basecheminfichier2 = baseheurefichier2.Delete(baseguillemet,longueurligne);
char apercuheurefichier[20];
sprintf(apercuheurefichier,"%s",baseheurefichier2);
structure[lignetableau].heurefichier = apercuheurefichier;
lignetableau++;
//sortie de la boucle if != '|'
}
//sortie de la boucle while !eof
}
int stop2 = (GetTickCount() - start2)/1000;
char temps3[150];
sprintf(temps3,"Remplissage de la base de données de la base de données séléctionnées terminé en : %d s",stop2);
Form1->Label11->Caption = temps3;
Application->ProcessMessages();
//MessageBox(NULL,"premiere structure remplie (celle de la base de données)","toute les données sont dans la structure",MB_ICONSTOP);
//***************************************************************************************************************
//**************début de la partie de la quatrième méthode de la base de données*********************************
//***************************************************************************************************************
//***************************************************************************************************************
// la variable ligne contient le nombre de ligne de la base de référence
int start4 = GetTickCount();
Form1->Label12->Visible = true;
Form1->Label12->Caption = "Tri de la base de données séléctionnées en cours";
Application->ProcessMessages();
int lostk[200], histk[200];
int stkptr = 0;
//MessageBox(NULL,"nombre de ligne de la référence","a quand meme",MB_ICONSTOP);
int ligneter;
int mid,lo,hi;
//ShowMessage(ligne);
ligneter = ligne/2;
//MessageBox(NULL,"nombre de ligne de la référence/2","a quand meme",MB_ICONSTOP);
//ShowMessage(ligneter);
lo = 0;
//hi = ligne;
hi = lignedix-1;
recurse:
int loguy = lo;
int higuy = hi;
//a rajouter le cas ou la taille <= 8 alors tri court
int size = hi - lo;
if (size < 8) {
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "il y a moins de 8 éléments premier tri\t loguy: \t%d\t higuy: \t%d\t hi:\t%d\t lo:\t%d \n",loguy,higuy,hi,lo);
//fclose(dossieressaibis);
int numeroligne;
int lignereference;
for (int tabis = lo; tabis < hi;tabis++)
{
lignereference = tabis;
for (int tater = tabis+1; tater <= hi;tater++)
{
if (structure[tater].fichierbase < structure[lignereference].fichierbase) lignereference = tater;
}
if (lignereference > tabis)
//tri nom fichier
{
structure[0].temporaire = structure[tabis].fichierbase;
structure[tabis].fichierbase = structure[lignereference].fichierbase;
structure[lignereference].fichierbase = structure[0].temporaire;
//tri taille fichier
structure[0].temporaire = structure[tabis].taillefichier;
structure[tabis].taillefichier = structure[lignereference].taillefichier;
structure[lignereference].taillefichier = structure[0].temporaire;
//tri date fichier
structure[0].temporaire = structure[tabis].datefichier;
structure[tabis].datefichier = structure[lignereference].datefichier;
structure[lignereference].datefichier = structure[0].temporaire;
//tri heure fichier
structure[0].temporaire = structure[tabis].heurefichier;
structure[tabis].heurefichier = structure[lignereference].heurefichier;
structure[lignereference].heurefichier = structure[0].temporaire;
}
}
}
if (size < 8) goto goSTACK;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "********voici la liste après tri des moins de 8 éléments\n");
//for (int yeah = lo; yeah <= hi;yeah++)
//{
//AnsiString textebasedonneese = structure[yeah].fichierbase.c_str();
//fprintf (dossieressaibis, "%d\t%s\n",yeah,textebasedonneese);
//}
//fclose(dossieressaibis);
mid = (lo + hi)/2; /* find middle element */
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "voici la valeur de mid:\t%d\n",mid);
//fclose(dossieressaibis);
if (structure[lo].fichierbase > structure[mid].fichierbase)
{
//tri nom fichier
structure[0].temporaire = structure[lo].fichierbase;
structure[lo].fichierbase = structure[mid].fichierbase;
structure[mid].fichierbase = structure[0].temporaire;
//tri taille fichier
structure[0].temporaire = structure[lo].taillefichier;
structure[lo].taillefichier = structure[mid].taillefichier;
structure[mid].taillefichier = structure[0].temporaire;
//tri date fichier
structure[0].temporaire = structure[lo].datefichier;
structure[lo].datefichier = structure[mid].datefichier;
structure[mid].datefichier = structure[0].temporaire;
//tri heure fichier
structure[0].temporaire = structure[lo].heurefichier;
structure[lo].heurefichier = structure[mid].heurefichier;
structure[mid].heurefichier = structure[0].temporaire;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "valeur de lo LO>MID :\t%d\t valeur de mid:\t\n",structure[lo].fichierbase,structure[mid].fichierbase);
//fclose(dossieressaibis);
}
if (structure[lo].fichierbase > structure[hi].fichierbase)
{
//tri nom fichier
structure[0].temporaire = structure[lo].fichierbase;
structure[lo].fichierbase = structure[hi].fichierbase;
structure[hi].fichierbase = structure[0].temporaire;
//tri taille fichier
structure[0].temporaire = structure[lo].taillefichier;
structure[lo].taillefichier = structure[hi].taillefichier;
structure[hi].taillefichier = structure[0].temporaire;
//tri date fichier
structure[0].temporaire = structure[lo].datefichier;
structure[lo].datefichier = structure[hi].datefichier;
structure[hi].datefichier = structure[0].temporaire;
//tri heure fichier
structure[0].temporaire = structure[lo].heurefichier;
structure[lo].heurefichier = structure[hi].heurefichier;
structure[hi].heurefichier = structure[0].temporaire;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "valeur de lo LO>HI:\t%s\t valeur de hi:\t%s\n",structure[lo].fichierbase,structure[hi].fichierbase);
//fclose(dossieressaibis);
}
if (structure[mid].fichierbase > structure[hi].fichierbase)
{
//tri nom fichier
structure[0].temporaire = structure[mid].fichierbase;
structure[mid].fichierbase = structure[hi].fichierbase;
structure[hi].fichierbase = structure[0].temporaire;
//tri taille fichier
structure[0].temporaire = structure[mid].taillefichier;
structure[mid].taillefichier = structure[hi].taillefichier;
structure[hi].taillefichier = structure[0].temporaire;
//tri date fichier
structure[0].temporaire = structure[mid].datefichier;
structure[mid].datefichier = structure[hi].datefichier;
structure[hi].datefichier = structure[0].temporaire;
//tri heure fichier
structure[0].temporaire = structure[mid].heurefichier;
structure[mid].heurefichier = structure[hi].heurefichier;
structure[hi].heurefichier = structure[0].temporaire;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "valeur de mid:\t%d\t valeur de hi:\t\%dn",mid,hi);
//fclose(dossieressaibis);
}
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "voici le loguy = lo: \t%d et le higuy = hi:\t%d \n",loguy,higuy);
//fclose(dossieressaibis);
for(;;) {
if(mid > loguy) {
do {
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//for (int yeah = lo; yeah < hi;yeah++)
//{
//AnsiString baseselection = structurebis[testlecture].fichierbasebis.c_str();
//AnsiString textebasedonneese = structure[yeah].fichierbase.c_str();
//fprintf (dossieressaibis, "liste des elements dans do %d\t%s\n",yeah,textebasedonneese);
//}
//fclose(dossieressaibis);
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "voici le loguy 0 MID > LOGUY\t%d\t contenu de loguy:\t%s\t valeur de mid: \t%d\t contenu de mid:\t%s\n",loguy,structure[loguy].fichierbase.c_str(),mid,structure[mid].fichierbase.c_str());
// fclose(dossieressaibis);
loguy++;//loguy += FULLVL;
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "voici le loguy 1 MID > LOGUY\t%d\t contenu de loguy:\t%s\t valeur de mid: \t%d\t contenu de mid:\t%s \n",loguy,structure[loguy].fichierbase.c_str(),mid,structure[mid].fichierbase.c_str());
// fclose(dossieressaibis);
// MessageBox(NULL,"ca bug??","a oui ca bug",MB_ICONSTOP);
//fermeture de do
} while (loguy < mid && strcmp(structure[loguy].fichierbase.c_str(),structure[mid].fichierbase.c_str())<= 0);
//fermeture de if(mid > loguy)
}
// if(mid <= loguy) { //attention s'agit-il bien de loguy??????
if(mid <= loguy) {
do {
loguy ++;
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "voici le loguy 2 MID <= LOGUY \t%d\t contenu de loguy:\t%s\t valeur de mid: \t%d\t contenu de mid:\t%s \n",loguy,structure[loguy].fichierbase.c_str(),mid,structure[mid].fichierbase.c_str());
// fclose(dossieressaibis);
// MessageBox(NULL,"ca bug8??","a oui ca bug",MB_ICONSTOP);
//fermeture de do
} while(loguy <= hi && strcmp(structure[loguy].fichierbase.c_str(),structure[mid].fichierbase.c_str())<= 0);
// fermeture de if (mid <= loguy)
}
do {
higuy --;
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "voici le higuy 1 \t%d\t contenu de higuy: \t%s\t valeur de mid: \t%d\t contenu de mid:\t%s\n",higuy,structure[higuy].fichierbase.c_str(),mid,structure[mid].fichierbase.c_str());
// fclose(dossieressaibis);
//fermeture de do
} while (higuy > mid && strcmp(structure[higuy].fichierbase.c_str(),structure[mid].fichierbase.c_str())> 0);
if(higuy < loguy) break;
//inversion nom fichier
structure[0].temporaire = structure[loguy].fichierbase;
structure[loguy].fichierbase = structure[higuy].fichierbase;
structure[higuy].fichierbase = structure[0].temporaire;
//inversion taille fichier
structure[0].temporaire = structure[loguy].taillefichier;
structure[loguy].taillefichier = structure[higuy].taillefichier;
structure[higuy].taillefichier = structure[0].temporaire;
//inversion date fichier
structure[0].temporaire = structure[loguy].datefichier;
structure[loguy].datefichier = structure[higuy].datefichier;
structure[higuy].datefichier = structure[0].temporaire;
//inversion heure fichier
structure[0].temporaire = structure[loguy].heurefichier;
structure[loguy].heurefichier = structure[higuy].heurefichier;
structure[higuy].heurefichier = structure[0].temporaire;
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "inversion entre loguy et higuy valeur higuy:\t%d\t contenu de higuy: \t%s\t valeur de loguy: \t%d\t contenu de loguy:\t%s\n",higuy,structure[higuy].fichierbase.c_str(),loguy,structure[loguy].fichierbase.c_str());
// fclose(dossieressaibis);
if(mid == higuy) mid = loguy;
//fermeture de for(;;;)
}
higuy++;
if(mid < higuy) {
do {
higuy --;
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "voici le higuy 2 mid < higuy \t%d\t contenu de higuy: \t%s\t valeur de mid: \t%d\t contenu de mid:\t%s\n",higuy,structure[higuy].fichierbase.c_str(),mid,structure[mid].fichierbase.c_str());
// fclose(dossieressaibis);
//fermeture de do
} while(higuy > mid && strcmp(structure[higuy].fichierbase.c_str(),structure[mid].fichierbase.c_str()) == 0);
//fermeture de if(mid<higuy)
}
if(mid >= higuy) {
do {
higuy --;
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "voici le higuy 3 mid >= higuy \t%d\t contenu de higuy: \t%s\t valeur de mid: \t%d\t contenu de mid:\t%s\n",higuy,structure[higuy].fichierbase.c_str(),mid,structure[mid].fichierbase.c_str());
// fclose(dossieressaibis);
//for (int yeah = 0; yeah < lignedix-1;yeah++) {
// AnsiString textebasedonneese = structure[yeah].fichierbase.c_str();
// fprintf (dossieressaibis, "%d\t%s\n",yeah,textebasedonneese);
// }
//fermeture de do
} while(higuy > lo && strcmp(structure[higuy].fichierbase.c_str(),structure[mid].fichierbase.c_str()) == 0);
//fermeture de if(mid>=higuy)
}
if(higuy - lo >= hi - loguy) {
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "(higuy - lo >= hi - loguy)\t valeur de higuy:\t%d\t valeur de lo:\t%d\t valeur de hi:\t%d\t valeur de loguy:\t%d\n",higuy,lo,hi,loguy);
// fclose(dossieressaibis);
if(lo < higuy) {
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "(lo < higuy\n");
// fclose(dossieressaibis);
lostk[stkptr] = lo;
histk[stkptr] = higuy;
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "(valeur stkptr:\t%d\t lostk[stkptr]: \t%d\t histk[stkptr]:\t%d\n",stkptr,lostk[stkptr],histk[stkptr]);
// fclose(dossieressaibis);
++stkptr;
//fermeture de if(lo < higuy)
} /* save big recursion for later */
if(loguy < hi) {
lo = loguy;
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "(loguy < hi\t valeur de lo: %d\t valeur de loguy\t%d\t valeur de hi\t%d\n",lo,loguy,hi);
// fclose(dossieressaibis);
// MessageBox(NULL,"Alors la on recurse","pour le premier",MB_ICONSTOP);
goto recurse; /* do small recursion */
//fermeture de if (loguy<hi)
}
} //EXISTE DANS LA VERSION ORIGINALE MAIS NE COMPILE PAS AVEC
else {
if(loguy < hi) {
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "(loguy < hi\n");
// fclose(dossieressaibis);
lostk[stkptr] = loguy;
histk[stkptr] = hi;
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "(valeur stkptr:\t%d\t lostk[stkptr]: \t%d\t histk[stkptr]:\t%d\n",stkptr,lostk[stkptr],histk[stkptr]);
// fclose(dossieressaibis);
++stkptr; /* save big recursion for later */
//fermeture de loguy < hi
}
if(lo < higuy) {
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "(lo < higuy\n");
// fclose(dossieressaibis);
hi = higuy;
// MessageBox(NULL,"Alors la on recurse","pour le second",MB_ICONSTOP);
goto recurse; /* do small recursion */
//fermeture de if(lo<higuy)
}
//fermeture de else
}
goSTACK:
if(--stkptr >= 0) {
lo = lostk[stkptr];
hi = histk[stkptr];
// MessageBox(NULL,"Alors la on recurse","pour le troisième",MB_ICONSTOP);
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "on recurse juste avant la sortie\n");
// fclose(dossieressaibis);
goto recurse; /* pop subarray from stack */
// fermeture de if(--stkptr >= 0)
}
//MessageBox(NULL,"tri de la base de données de référence terminée","on va la trier",MB_ICONINFORMATION);
// } EXISTE DANS LA VERSION ORIGINALE MAIS NE COMPILE PAS AVEC
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "sortie du programme\n");
// fclose(dossieressaibis);
//fermeture de (higuy - lo >= hi - loguy)
//}
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "sortie du programme bis\n");
//fclose(dossieressaibis);
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "********liste après tri de la base de données de référence**********\n");
//************************************************************************************************************
//************************************************************************************************************
//************************************************************************************************************
//for (int yeah = 0; yeah < lignedix-1;yeah++) {
// AnsiString textebasedonneese = structure[yeah].fichierbase.c_str();
// fprintf (dossieressaibis, "%d\t%s\n",yeah,textebasedonneese);
// }
//fclose(dossieressaibis);
//************************************************************************************************************
//************************************************************************************************************
//************************************************************************************************************
//***************************************************************************************************************
//**************fin de la partie de la quatrième méthode*********************************************************
//***************************************************************************************************************
//***************************************************************************************************************
//***************************************************************************************************************
//***************************************************************************************************************
//**************tri des trois autres parties de la base de données***********************************************
//***************************************************************************************************************
//***************************************************************************************************************
//**************en premier on commence par la date***************************************************************
int NS,nomsuivant,tailleordre,tailleordrebis,memenom,dateordre;
for (memenom=0;memenom<lignedix;memenom++)
{
if (structure[memenom].fichierbase == structure[memenom+1].fichierbase)
{
nomsuivant = 1;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "memenom:\t%dnom fichier\t%s\tmemenom+1:%d\tnom fichier suivant:%s\n",memenom,structure[memenom].fichierbase.c_str(),memenom+1,structure[memenom+1].fichierbase.c_str());
//fclose(dossieressaibis);
// do
NS = strcmp(structure[memenom].fichierbase.c_str(),structure[memenom+nomsuivant].fichierbase.c_str());
while (NS == 0 && memenom+nomsuivant < lignedix)
{
NS = strcmp(structure[memenom].fichierbase.c_str(),structure[memenom+nomsuivant].fichierbase.c_str());
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "memenom:\t%dnom fichier\t%s\tmemenom+nom suivant:%d\tnom fichier suivant:%s\n",memenom,structure[memenom].fichierbase.c_str(),memenom+nomsuivant,structure[memenom+nomsuivant].fichierbase.c_str());
// fclose(dossieressaibis);
nomsuivant++;
NS = strcmp(structure[memenom].fichierbase.c_str(),structure[memenom+nomsuivant].fichierbase.c_str());
}//while(NS == 0 && memenom+nomsuivant < lignedix);
for (dateordre = memenom; dateordre < memenom+nomsuivant;dateordre++)
{
int lignereferencebis = dateordre;
for (int dateordrebis = dateordre+1; dateordrebis < memenom+nomsuivant;dateordrebis++)
{
if (structure[dateordrebis].datefichier < structure[lignereferencebis].datefichier)
{
lignereferencebis = dateordrebis;
}
}
if (lignereferencebis > dateordre)
//tri nom fichier
{
structure[0].temporaire = structure[dateordre].fichierbase;
structure[dateordre].fichierbase = structure[lignereferencebis].fichierbase;
structure[lignereferencebis].fichierbase = structure[0].temporaire;
//tri taille fichier
structure[0].temporaire = structure[dateordre].taillefichier;
structure[dateordre].taillefichier = structure[lignereferencebis].taillefichier;
structure[lignereferencebis].taillefichier = structure[0].temporaire;
//tri date fichier
structure[0].temporaire = structure[dateordre].datefichier;
structure[dateordre].datefichier = structure[lignereferencebis].datefichier;
structure[lignereferencebis].datefichier = structure[0].temporaire;
//tri heure fichier
structure[0].temporaire = structure[dateordre].heurefichier;
structure[dateordre].heurefichier = structure[lignereferencebis].heurefichier;
structure[lignereferencebis].heurefichier = structure[0].temporaire;
}
}
//sortie de if structure[memenom].fichierbase == structure[memenom+1].fichierbase)
}
//sortie de for (memenom=0;memenom<lignedix;memenom++)
}
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "*****************premier tri par date*****************\n");
// for (int yeah = 0; yeah < lignedix-1;yeah++) {
// AnsiString textebasedonneese = structure[yeah].fichierbase.c_str();
// fprintf (dossieressaibis, "tri fini: %d\t%s\tdate fichier: %s\t heure fichier: %s\ttaillefichier: %s\n",yeah,textebasedonneese,structure[yeah].datefichier.c_str(),structure[yeah].heurefichier.c_str(),structure[yeah].taillefichier.c_str());
// }
//fclose(dossieressaibis);
//********puis on continue par l'heure du fichier*******************************
//int NS1,nomsuivant1,tailleordre,tailleordrebis,memenom1,heureordre;
int NS1,nomsuivant1,memenom1,heureordre,NS2;
for (memenom1=0;memenom1<lignedix;memenom1++)
{
if (structure[memenom1].fichierbase == structure[memenom1+1].fichierbase && structure[memenom1].datefichier == structure[memenom1+1].datefichier)
{
nomsuivant1 = 0;
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "tri heure memenom1:\t%dnom fichier\t%s\tdate fichier: %s\tmemenom1+1:%d\tnom fichier suivant:%s\tdate fichier suivant: %s\n",memenom1,structure[memenom1].fichierbase.c_str(),structure[memenom1].datefichier.c_str(),memenom1+1,structure[memenom1+1].fichierbase.c_str(),structure[memenom1+1].datefichier.c_str());
// fclose(dossieressaibis);
NS1 = strcmp(structure[memenom1].fichierbase.c_str(),structure[memenom1+nomsuivant1].fichierbase.c_str());
NS2 = strcmp(structure[memenom1].datefichier.c_str(),structure[memenom1+nomsuivant1].datefichier.c_str());
while (NS1 == 0 && NS2 == 0 && memenom1+nomsuivant1 < lignedix)
// do
{
// NS1 = strcmp(structure[memenom1].fichierbase.c_str(),structure[memenom1+nomsuivant1].fichierbase.c_str());
// NS2 = strcmp(structure[memenom1].datefichier.c_str(),structure[memenom1+nomsuivant1].datefichier.c_str());
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "boucle do de heure memenom1:\t%dnom fichier:\t%s\tdate fichier:\t%s\theure fichier:%s\tmemenom1+nom suivant:%d\tnom fichier suivant:%s\tdate fichier:%s\theure fichier:\t%s\n",memenom1,structure[memenom1].fichierbase.c_str(),structure[memenom1].datefichier.c_str(),structure[memenom1].heurefichier.c_str(),memenom1+nomsuivant1,structure[memenom1+nomsuivant1].fichierbase.c_str(),structure[memenom1+nomsuivant1].datefichier.c_str(),structure[memenom1+nomsuivant1].heurefichier.c_str());
// fclose(dossieressaibis);
nomsuivant1++;
NS1 = strcmp(structure[memenom1].fichierbase.c_str(),structure[memenom1+nomsuivant1].fichierbase.c_str());
NS2 = strcmp(structure[memenom1].datefichier.c_str(),structure[memenom1+nomsuivant1].datefichier.c_str());
}
for (heureordre = memenom1; heureordre < memenom1+nomsuivant1;heureordre++)
{
int lignereferencebis = heureordre;
//for (int heureordrebis = heureordre+1; heureordrebis < memenom1+nomsuivant1;heureordrebis++)
for (int heureordrebis = heureordre+1; heureordrebis < memenom1+nomsuivant1;heureordrebis++)
{
if (structure[heureordrebis].heurefichier < structure[lignereferencebis].heurefichier)
{
lignereferencebis = heureordrebis;
//lignereferencebis = heureordre;
}
}
if (lignereferencebis > heureordre)
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "*****permutation section heure valeur lignerefencebis:%d\tvaleur heureordre:\t%d\nalors la on permute memenom1:\t%dnom fichier\t%s\tdate fichier\t%s\tmemenom1+nom suivant:%d\tnom fichier suivant:%s\tdate fichier:%s\n",lignereferencebis,heureordre,lignereferencebis,structure[lignereferencebis].fichierbase.c_str(),structure[lignereferencebis].datefichier.c_str(),heureordre,structure[heureordre].fichierbase.c_str(),structure[heureordre].datefichier.c_str());
// fclose(dossieressaibis);
{
//tri nom fichier
structure[0].temporaire = structure[heureordre].fichierbase;
structure[heureordre].fichierbase = structure[lignereferencebis].fichierbase;
structure[lignereferencebis].fichierbase = structure[0].temporaire;
//tri taille fichier
structure[0].temporaire = structure[heureordre].taillefichier;
structure[heureordre].taillefichier = structure[lignereferencebis].taillefichier;
structure[lignereferencebis].taillefichier = structure[0].temporaire;
//tri date fichier
structure[0].temporaire = structure[heureordre].datefichier;
structure[heureordre].datefichier = structure[lignereferencebis].datefichier;
structure[lignereferencebis].datefichier = structure[0].temporaire;
//tri heure fichier
structure[0].temporaire = structure[heureordre].heurefichier;
structure[heureordre].heurefichier = structure[lignereferencebis].heurefichier;
structure[lignereferencebis].heurefichier = structure[0].temporaire;
}
}
//sortie de if structure[memenom1].fichierbase == structure[memenom1+1].fichierbase)
}
//sortie de for (memenom1=0;memenom1<lignedix;memenom1++)
}
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "*****************premier tri par heure*****************\n");
// for (int yeah = 0; yeah < lignedix-1;yeah++) {
// AnsiString textebasedonneese = structure[yeah].fichierbase.c_str();
// fprintf (dossieressaibis, "tri fini: %d\t%s\tdate fichier: %s\t heure fichier: %s\ttaillefichier: %s\n",yeah,textebasedonneese,structure[yeah].datefichier.c_str(),structure[yeah].heurefichier.c_str(),structure[yeah].taillefichier.c_str());
// }
//fclose(dossieressaibis);
//*******enfin pour finir la taille*********************************************
int NS3,nomsuivant2,memenom2,tailleordreter,NS4,NS5;
for (memenom2=0;memenom2<lignedix;memenom2++)
{
if (structure[memenom2].fichierbase == structure[memenom2+1].fichierbase && structure[memenom2].datefichier == structure[memenom2+1].datefichier &&structure[memenom2].heurefichier == structure[memenom2+1].heurefichier )
{
nomsuivant2 = 0;
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "tri taille memenom2:\t%dnom fichier\t%s\tdate fichier: %s\tmemenom2+1:%d\tnom fichier suivant:%s\tdate fichier suivant: %s\n",memenom2,structure[memenom2].fichierbase.c_str(),structure[memenom2].datefichier.c_str(),memenom2+1,structure[memenom2+1].fichierbase.c_str(),structure[memenom2+1].datefichier.c_str());
// fclose(dossieressaibis);
NS3 = strcmp(structure[memenom2].fichierbase.c_str(),structure[memenom2+nomsuivant2].fichierbase.c_str());
NS4 = strcmp(structure[memenom2].datefichier.c_str(),structure[memenom2+nomsuivant2].datefichier.c_str());
NS5 = strcmp(structure[memenom2].heurefichier.c_str(),structure[memenom2+nomsuivant2].heurefichier.c_str());
// do
while(NS3 == 0 && NS4 == 0 && NS5 == 0 && memenom2+nomsuivant2 < lignedix)
{
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "boucle do de taille memenom2:\t%dnom fichier\t%s\tdate fichier\t%s\t\heure fichier:%s\tmemenom2+nom suivant:%d\tnom fichier suivant:%s\tdate fichier:%s\t\heure fichier:%s\n",memenom2,structure[memenom2].fichierbase.c_str(),structure[memenom2].datefichier.c_str(),structure[memenom2].heurefichier.c_str(),memenom2+nomsuivant2,structure[memenom2+nomsuivant2].fichierbase.c_str(),structure[memenom2+nomsuivant2].datefichier.c_str(),structure[memenom2+nomsuivant2].heurefichier.c_str());
// fclose(dossieressaibis);
nomsuivant2++;
NS3 = strcmp(structure[memenom2].fichierbase.c_str(),structure[memenom2+nomsuivant2].fichierbase.c_str());
NS4 = strcmp(structure[memenom2].datefichier.c_str(),structure[memenom2+nomsuivant2].datefichier.c_str());
NS5 = strcmp(structure[memenom2].heurefichier.c_str(),structure[memenom2+nomsuivant2].heurefichier.c_str());
}//while(NS3 == 0 && NS4 == 0 && NS5 == 0 && memenom2+nomsuivant2 < lignedix);
for (tailleordreter = memenom2; tailleordreter < memenom2+nomsuivant2;tailleordreter++)
{
int lignereferencebis = tailleordreter;
//for (int tailleordreterbis = tailleordreter+1; tailleordreterbis < memenom2+nomsuivant2;tailleordreterbis++)
for (int tailleordreterbis = tailleordreter+1; tailleordreterbis < memenom2+nomsuivant2;tailleordreterbis++)
{
if (structure[tailleordreterbis].taillefichier < structure[lignereferencebis].taillefichier)
{
//lignereferencebis = tailleordreterbis;
lignereferencebis = tailleordreterbis;
}
}
if (lignereferencebis > tailleordreter)
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "alors la on permute memenom2:\t%dnom fichier\t%s\tdate fichier\t%s\tmemenom2+nom suivant:%d\tnom fichier suivant:%s\tdate fichier:%s\n",lignereferencebis,structure[lignereferencebis].fichierbase.c_str(),structure[lignereferencebis].datefichier.c_str(),tailleordreter,structure[tailleordreter].fichierbase.c_str(),structure[tailleordreter].datefichier.c_str());
// fclose(dossieressaibis);
{
//tri nom fichier
structure[0].temporaire = structure[tailleordreter].fichierbase;
structure[tailleordreter].fichierbase = structure[lignereferencebis].fichierbase;
structure[lignereferencebis].fichierbase = structure[0].temporaire;
//tri taille fichier
structure[0].temporaire = structure[tailleordreter].taillefichier;
structure[tailleordreter].taillefichier = structure[lignereferencebis].taillefichier;
structure[lignereferencebis].taillefichier = structure[0].temporaire;
//tri date fichier
structure[0].temporaire = structure[tailleordreter].datefichier;
structure[tailleordreter].datefichier = structure[lignereferencebis].datefichier;
structure[lignereferencebis].datefichier = structure[0].temporaire;
//tri heure fichier
structure[0].temporaire = structure[tailleordreter].heurefichier;
structure[tailleordreter].heurefichier = structure[lignereferencebis].heurefichier;
structure[lignereferencebis].heurefichier = structure[0].temporaire;
}
}
//sortie de if structure[memenom2].fichierbase == structure[memenom2+1].fichierbase)
}
//sortie de for (memenom2=0;memenom2<lignedix;memenom2++)
}
//*********fin tri des autres elements
int stop4 = (GetTickCount() - start4)/1000;
char temps4[256];
sprintf(temps4,"Tri de la base de données séléctionnées terminé en : %d s",stop4);
Form1->Label12->Caption = temps4;
Application->ProcessMessages();
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "*****************premier tri par taille de la base de données de référence*****************\n");
// for (int yeah = 0; yeah < lignedix-1;yeah++) {
// AnsiString textebasedonneese = structure[yeah].fichierbase.c_str();
// fprintf (dossieressaibis, "tri fini: %d\t%s\tdate fichier: %s\t heure fichier: %s\ttaillefichier: %s\n",yeah,textebasedonneese,structure[yeah].datefichier.c_str(),structure[yeah].heurefichier.c_str(),structure[yeah].taillefichier.c_str());
// }
//fclose(dossieressaibis);
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//for (int yeah = 0; yeah < lignedix-1;yeah++) {
// AnsiString textebasedonneese = structure[yeah].fichierbase.c_str();
// fprintf (dossieressaibis, "tri fini: %d\t%s\tdate fichier: %s\t heure fichier: %s\ttaillefichier: %s\n",yeah,textebasedonneese,structure[yeah].datefichier.c_str(),structure[yeah].heurefichier.c_str(),structure[yeah].taillefichier.c_str());
// }
//fclose(dossieressaibis);
//MessageBox(NULL,"LE TRI QUATRIEME METHODE TERMINE POUR LA BASE DE DONNEE","DEJA",MB_ICONSTOP);
//***************************************************************************************************************
//**************début de la partie de la troisième méthode*******************************************************
//***************************************************************************************************************
//***************************************************************************************************************
//MessageBox(NULL,"liste doublement chainée crée","liste doublement chainee EN DEBUT DE TRI",MB_ICONSTOP);
//Pour cette méthode une liste doublement chaînée va être employer afin de trié directement dans celui-ci dès la
//première ligne.
//Pour ce faire dans la liste doublement chaînée sera placé le numéro de la ligne du tableau, en premier on place
//la ligne n°1 du tableau dans le premier élément de la chaîne puis on lit la seconde ligne du tableau puis l'on
//compare la ligne 1 et la 2 si la seconde ligne du tableau est plus petite alors on la place avant le premier
//élément de la liste chaînée et ainsi de suite.
//Création de la liste doublement chaînée.
// La liste doublement chainee fait appel à des fonctions crées plus haut dont on fait appel
// Le nombre d'éléments crées correspondra à lignetableau qui correspond au nombre d'élément dans le tableau
// dynamique de référence.
//boucle qui liste la structure puis la compare à la liste chainée
//char lire3 [120];
//int compteur = 1;
//for (int listage = 1;listage<lignetableau;listage++)
//{
//if (listage == lignetableau-1)
//{
// dossierlist = fopen("c:\\pouressai\\fichierlist.xrdb","a");
//MessageBox(NULL,"nous voici dans le listage de la liste","fichier isolé la structure de la selection debut de la première boucle (lire)",MB_ICONSTOP);
//Chose *pC;
//pC=pPrem;
//while(pC)
// {
// sprintf(lire3,"%s", structure[pC->listcounter].fichierbase.c_str());
// fprintf (dossierlist, "%s\n",lire3);
// pC=pC->pSuiv;
// }
//}
//int Z;
//char lire[120];
// lire contient l'élément de la structure de la référence
//sprintf(lire,"%s", structure[listage].fichierbase.c_str());
// listage de la liste chainée
//Chose *pC;
//pC=pPrem;
// if (listage == 1)
// {
// pPrem=new Chose();
// pPrem->listcounter= 1;
// pPrem->pSuiv=NULL;
// pPrem->pPrec=NULL;
// pC=pPrem;
// goto finfor;
// }
//while(pC)
// {
//char lire2 [120];
//sprintf(lire2,"%s", structure[pC->listcounter].fichierbase.c_str());
//char lire5 [120];
//sprintf(lire5,"%s", structure[listage].fichierbase.c_str());
//Z = CompareStr(lire, lire2);
//if (Z < 0)
//{
//insertion d'un élément en première position
//if (pC == pPrem)
//{
//pPrem=new Chose();
//pPrem->pSuiv=pC;
//pPrem->listcounter=listage;
//pC=pC->pSuiv;
//goto finfor;
//}
//Chose *pMem;
// pMem=pC;
// pC=pC->pSuiv;
//pMem->pSuiv=new Chose();
//pMem->pSuiv->listcounter=listage;
//pMem->pSuiv->pSuiv=pC;
// compteur++;
// char compteur2[120];
// sprintf(compteur2,"%d",compteur);
//goto finfor;
//sortie du if Z < 0
// }
//pC=pC->pSuiv;
//sortie du while(pC)
//}
//Chose *pM;
//pC=pPrem;
//while(pC)
// {
// pM=pC;
// pC=pC->pSuiv;
// }
//pDern=new Chose();
//pM->pSuiv=pDern;
//pM->pSuiv->listcounter=listage;
//pM->pSuiv->pSuiv=NULL;
//pM->pSuiv->pPrec=pM;
// finfor:
// }
//MessageBox(NULL,"liste doublement chainée crée","liste doublement chainee TRIEE",MB_ICONSTOP);
//***************************************************************************************************************
//**************fin de la partie de la troisième méthode*********************************************************
//***************************************************************************************************************
//***************************************************************************************************************
//***************************************************************************************************************
//**************début de la partie de la seconde méthode*********************************************************
//***************************************************************************************************************
//MessageBox(NULL,"début de la seconde methode de tri","que la force soit avec nous",MB_ICONSTOP);
//int numeroligne;
//int lignereference;
//for (int tabis = 0; tabis < lignetableau;tabis++)
//{
//lignereference = tabis;
//for (int tater = tabis+1; tater < lignetableau;tater++)
//{
//if (structure[tater].fichierbase < structure[lignereference].fichierbase)
//{
//lignereference = tater;
//}
//}
//if (lignereference > tabis)
//tri nom fichier
//{
//structure[0].temporaire = structure[tabis].fichierbase;
//structure[tabis].fichierbase = structure[lignereference].fichierbase;
//structure[lignereference].fichierbase = structure[0].temporaire;
//tri taille fichier
//structure[0].temporaire = structure[tabis].taillefichier;
//structure[tabis].taillefichier = structure[lignereference].taillefichier;
//structure[lignereference].taillefichier = structure[0].temporaire;
//tri date fichier
//structure[0].temporaire = structure[tabis].datefichier;
//structure[tabis].datefichier = structure[lignereference].datefichier;
//structure[lignereference].datefichier = structure[0].temporaire;
//tri heure fichier
//structure[0].temporaire = structure[tabis].heurefichier;
//structure[tabis].heurefichier = structure[lignereference].heurefichier;
//structure[lignereference].heurefichier = structure[0].temporaire;
//}
//}
//MessageBox(NULL,"tri seconde méthode de la base de reference terminé","tri base ok",MB_ICONSTOP);
//***************************************************************************************************************
//**************fin de la partie de la seconde méthode***********************************************************
//***************************************************************************************************************
//***************************************************************************************************************
//création de la base de donnees (tableau dynamique) du dossier ou lecteur selectionné a verifier
//******************************************************************************
//******************************************************************************
int start5 = GetTickCount();
Form1->Label13->Visible = true;
Form1->Label13->Caption = "Création base de données du dossier séléctionné en cours";
Application->ProcessMessages();
Sinebis* structurebis = NULL; //On initialise le pointeur sur la Structure à NULL
// int n = 10; //Valeur prise au hasard pour les besoins du problème
// structure = new Sine[n]; //On fait pointer structure sur un tableau de n Structures
structurebis = new Sinebis[lignebis+1]; //On fait pointer structure sur un tableau de n Structures
for(int i=0;i<=lignebis;i++){ //Boucle-test
structurebis[i].testbis = i; //Changement de la valeur du int
structurebis[i].textebis = ""; //Changement de celle du string
structurebis[i].fichierbasebis = "";
structurebis[i].cheminfichierbis = "";
structurebis[i].taillefichierbis = "";
structurebis[i].datefichierbis = "";
structurebis[i].heurefichierbis = "";
}
structurebis[0].temporairebis = "";
int stop5 = (GetTickCount() - start5)/1000;
char temps5[150];
sprintf(temps5,"Création base de données du dossier séléctionné terminé en : %d s",stop5);
Form1->Label13->Caption = temps5;
Application->ProcessMessages();
//MessageBox(NULL,"seconde structure de la base à verifier terminé","seconde structure en attente des éléments",MB_ICONSTOP);
//lecture du fichier c:\fichiertemporaire.txt
int start6 = GetTickCount();
Form1->Label14->Visible = true;
Form1->Label14->Caption = "Remplissage de la base de données du dossier séléctionné en cours";
Application->ProcessMessages();
ifstream infile4 (basedonneesbis);
if (!infile4) return;
while (!infile4.eof())
{
infile4.getline(motbis,sizeof(motbis));
//if (motbis[0] != '|' )
if (motbis[0] != '|' && motbis != NULL)
//si la ligne du fichier c:\fichiertemporaire.txt ne commence pas par | alors
{
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "\n\n*****************lignes récupérées depuis le fichier temporaire *****************\n");
// fprintf (dossieressaibis," %sstop" ,motbis);
// fclose(dossieressaibis);
//recupération de la ligne du fichier
AnsiString baselignebis = motbis;
int longueurlignebis = StrLen(motbis);
int baseguillemetbis = 0;
baseguillemetbis = baselignebis.AnsiPos(";");
AnsiString basecheminfichier2bis = baselignebis;
//MessageBox(NULL,motbis,"ligne lu",MB_ICONSTOP);
//ShowMessage(lignetableaubis);
basecheminfichier2bis = basecheminfichier2bis.Delete(baseguillemetbis,longueurlignebis);
char apercustringbis[500];
sprintf(apercustringbis,"%s",basecheminfichier2bis);
//MessageBox(NULL,apercustringbis,"chemin fichier",MB_ICONSTOP);
structurebis[lignetableaubis].cheminfichierbis = apercustringbis;
//isolement nom fichierbis
baselignebis = baselignebis.Delete(1,baseguillemetbis);
baseguillemetbis = baselignebis.AnsiPos(";");
AnsiString basenomfichier2bis = baselignebis;
basecheminfichier2bis = basenomfichier2bis.Delete(baseguillemetbis,longueurlignebis);
char apercunomfichierbis[256];
sprintf(apercunomfichierbis,"%s",basenomfichier2bis);
structurebis[lignetableaubis].fichierbasebis = apercunomfichierbis;
//MessageBox(NULL,structurebis[lignetableaubis].fichierbasebis.c_str(),"fichier isolé la structure de la selection",MB_ICONSTOP);
//isolement de la taille du fichier
baselignebis = baselignebis.Delete(1,baseguillemetbis);
baseguillemetbis = baselignebis.AnsiPos(";");
AnsiString basetaillefichier2bis = baselignebis;
basecheminfichier2bis = basetaillefichier2bis.Delete(baseguillemetbis,longueurlignebis);
char apercutaillefichierbis[20];
sprintf(apercutaillefichierbis,"%s",basetaillefichier2bis);
structurebis[lignetableaubis].taillefichierbis = apercutaillefichierbis;
//MessageBox(NULL,structurebis[lignetableaubis].taillefichierbis.c_str(),"verif taille fichier",MB_ICONSTOP);
//isolement date du fichier
baselignebis = baselignebis.Delete(1,baseguillemetbis);
baseguillemetbis = baselignebis.AnsiPos(";");
AnsiString basedatefichier2bis = baselignebis;
basecheminfichier2bis = basedatefichier2bis.Delete(baseguillemetbis,longueurlignebis);
char apercudatefichierbis[20];
//sprintf(apercudatefichierbis,"%s",basedatefichier2bis);
//******rajouter pour inverser la date******
char apercudatefichierinversebis[20];
sprintf(apercudatefichierbis,"%s",basedatefichier2bis);
sprintf(apercudatefichierinversebis,"%s",basedatefichier2bis);
apercudatefichierbis[0] = apercudatefichierinversebis[6];
apercudatefichierbis[1] = apercudatefichierinversebis[7];
apercudatefichierbis[2] = apercudatefichierinversebis[8];
apercudatefichierbis[3] = apercudatefichierinversebis[9];
apercudatefichierbis[4] ='/';
apercudatefichierbis[5] = apercudatefichierinversebis[3];
apercudatefichierbis[6] = apercudatefichierinversebis[4];
apercudatefichierbis[7] ='/';
apercudatefichierbis[8] = apercudatefichierinversebis[0];
apercudatefichierbis[9] = apercudatefichierinversebis[1];
//******fin rajouter pour inverser la date******
structurebis[lignetableaubis].datefichierbis = apercudatefichierbis;
//isolement de l'heure du fichier
baselignebis = baselignebis.Delete(1,baseguillemetbis);
baseguillemetbis = baselignebis.AnsiPos(";");
AnsiString baseheurefichier2bis = baselignebis;
basecheminfichier2bis = baseheurefichier2bis.Delete(baseguillemetbis,longueurlignebis);
char apercuheurefichierbis[20];
sprintf(apercuheurefichierbis,"%s",baseheurefichier2bis);
structurebis[lignetableaubis].heurefichierbis = apercuheurefichierbis;
//on passe à la ligne suivante du tableau dynamique
lignetableaubis++;
//sortie de la boucle if != '|'
}
//sortie de la boucle while !eof
}
//MessageBox(NULL,"seconde structure remplie","seconde structure ok",MB_ICONSTOP);
int stop6 = (GetTickCount() - start6)/1000;
char temps6[150];
sprintf(temps6,"Remplissage de la base de données du dossier séléctionné terminé en : %d s",stop6);
Form1->Label14->Caption = temps6;
Application->ProcessMessages();
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "*****************premier tri par taille du dossier selectionné*****************\n");
// for (int yeah = 0; yeah < lignebis;yeah++) {
// AnsiString textebasedonneese = structurebis[yeah].fichierbasebis.c_str();
// fprintf (dossieressaibis, "tri fini: %d\t%s\tdate fichier: %s\t heure fichier: %s\ttaillefichier: %s\n",yeah,textebasedonneese,structurebis[yeah].datefichierbis.c_str(),structurebis[yeah].heurefichierbis.c_str(),structurebis[yeah].taillefichierbis.c_str());
// }fclose(dossieressaibis);
//***************************************************************************************************************
//**************début de la partie de la quatrième méthode de la base de séléctionné*****************************
//***************************************************************************************************************
//***************************************************************************************************************
// la variable ligne contient le nombre de ligne de la base de référence
int start7 = GetTickCount();
Form1->Label15->Visible = true;
Form1->Label15->Caption = "Tri de la base de données du dossier séléctionné en cours";
Application->ProcessMessages();
int lostk2[200], histk2[200];
int stkptr2 = 0;
int ligneter2;
int mid2,lo2,hi2;
ligneter2 = ligne2/2;
//ShowMessage(ligneter2);
lo2 = 0;
//hi2 = lignetableaubis-1;
hi2 = lignebis-1;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "balises du tableau\t lo2: \t%d\t hi2: \t%d\t \n",lo2,hi2);
//fclose(dossieressaibis);
recurse2:
int loguy2 = lo2;
int higuy2 = hi2;
int size2 = hi2 - lo2;
if (size2 < 8) {
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "il y a moins de 8 éléments premier tri\t loguy: \t%d\t higuy: \t%d\t hi:\t%d\t lo:\t%d \n",loguy,higuy,hi,lo);
//fclose(dossieressaibis);
int numeroligne2;
int lignereference2;
for (int tabis2 = lo2; tabis2 < hi2;tabis2++)
{
lignereference2 = tabis2;
for (int tater2 = tabis2+1; tater2 <= hi2;tater2++)
{
if (structurebis[tater2].fichierbasebis < structurebis[lignereference2].fichierbasebis) lignereference2 = tater2;
}
if (lignereference2 > tabis2)
{
//tri chemin fichier
structurebis[0].temporairebis = structurebis[tabis2].cheminfichierbis;
structurebis[tabis2].cheminfichierbis = structurebis[lignereference2].cheminfichierbis;
structurebis[lignereference2].cheminfichierbis = structurebis[0].temporairebis;
//tri nom fichier
structurebis[0].temporairebis = structurebis[tabis2].fichierbasebis;
structurebis[tabis2].fichierbasebis = structurebis[lignereference2].fichierbasebis;
structurebis[lignereference2].fichierbasebis = structurebis[0].temporairebis;
//tri taille fichier
structurebis[0].temporairebis = structurebis[tabis2].taillefichierbis;
structurebis[tabis2].taillefichierbis = structurebis[lignereference2].taillefichierbis;
structurebis[lignereference2].taillefichierbis = structurebis[0].temporairebis;
//tri date fichier
structurebis[0].temporairebis = structurebis[tabis2].datefichierbis;
structurebis[tabis2].datefichierbis = structurebis[lignereference2].datefichierbis;
structurebis[lignereference2].datefichierbis = structurebis[0].temporairebis;
//tri heure fichier
structurebis[0].temporairebis = structurebis[tabis2].heurefichierbis;
structurebis[tabis2].heurefichierbis = structurebis[lignereference2].heurefichierbis;
structurebis[lignereference2].heurefichierbis = structurebis[0].temporairebis;
}
}
}
if (size2 < 8) goto goSTACK2;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "********voici la liste après tri des moins de 8 éléments\n");
//for (int yeah = lo2; yeah <= hi2;yeah++)
//{
//AnsiString textebasedonneese = structurebis[yeah].fichierbasebis.c_str();
//fprintf (dossieressaibis, "%d\t%s\n",yeah,textebasedonneese);
//}
//fclose(dossieressaibis);
mid2 = (lo2 + hi2)/2; /* find middle element */
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "voici la valeur de mid:\t%d\n",mid2);
//fclose(dossieressaibis);
if (structurebis[lo2].fichierbasebis > structurebis[mid2].fichierbasebis)
{
//tri chemin fichier
structurebis[0].temporairebis = structurebis[lo2].cheminfichierbis;
structurebis[lo2].cheminfichierbis = structurebis[mid2].cheminfichierbis;
structurebis[mid2].cheminfichierbis = structurebis[0].temporairebis;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "tri chemin fichier:\t%s\n",structurebis[lo2].cheminfichierbis.c_str());
//fclose(dossieressaibis);
//tri nom fichier
structurebis[0].temporairebis = structurebis[lo2].fichierbasebis;
structurebis[lo2].fichierbasebis = structurebis[mid2].fichierbasebis;
structurebis[mid2].fichierbasebis = structurebis[0].temporairebis;
//tri taille fichier
structurebis[0].temporairebis = structurebis[lo2].taillefichierbis;
structurebis[lo2].taillefichierbis = structurebis[mid2].taillefichierbis;
structurebis[mid2].taillefichierbis = structurebis[0].temporairebis;
//tri date fichier
structurebis[0].temporairebis = structurebis[lo2].datefichierbis;
structurebis[lo2].datefichierbis = structurebis[mid2].datefichierbis;
structurebis[mid2].datefichierbis = structurebis[0].temporairebis;
//tri heure fichier
structurebis[0].temporairebis = structurebis[lo2].heurefichierbis;
structurebis[lo2].heurefichierbis = structurebis[mid2].heurefichierbis;
structurebis[mid2].heurefichierbis = structurebis[0].temporairebis;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "valeur de lo LO>MID :\t%d\t valeur de mid:\t\n",structure[lo].fichierbase,structure[mid].fichierbase);
//fclose(dossieressaibis);
}
if (structurebis[lo2].fichierbasebis > structurebis[hi2].fichierbasebis)
{
//tri chemin fichier
structurebis[0].temporairebis = structurebis[lo2].cheminfichierbis;
structurebis[lo2].cheminfichierbis = structurebis[hi2].cheminfichierbis;
structurebis[hi2].cheminfichierbis = structurebis[0].temporairebis;
//tri nom fichier
structurebis[0].temporairebis = structurebis[lo2].fichierbasebis;
structurebis[lo2].fichierbasebis = structurebis[hi2].fichierbasebis;
structurebis[hi2].fichierbasebis = structurebis[0].temporairebis;
//tri taille fichier
structurebis[0].temporairebis = structurebis[lo2].taillefichierbis;
structurebis[lo2].taillefichierbis = structurebis[hi2].taillefichierbis;
structurebis[hi2].taillefichierbis = structurebis[0].temporairebis;
//tri date fichier
structurebis[0].temporairebis = structurebis[lo2].datefichierbis;
structurebis[lo2].datefichierbis = structurebis[hi2].datefichierbis;
structurebis[hi2].datefichierbis = structurebis[0].temporairebis;
//tri heure fichier
structurebis[0].temporairebis = structurebis[lo2].heurefichierbis;
structurebis[lo2].heurefichierbis = structurebis[hi2].heurefichierbis;
structurebis[hi2].heurefichierbis = structurebis[0].temporairebis;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "valeur de lo2: %d\tvaleur de hi2: %d",lo2,hi2);
//fclose(dossieressaibis);
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "valeur de lo LO>HI:\t%s\t valeur de hi:\t%s\n",structurebis[lo2].fichierbasebis,structurebis[hi2].fichierbasebis);
//fclose(dossieressaibis);
}
if (structurebis[mid2].fichierbasebis > structurebis[hi2].fichierbasebis)
{
//tri chemin fichier
structurebis[0].temporairebis = structurebis[mid2].cheminfichierbis;
structurebis[mid2].cheminfichierbis = structurebis[hi2].cheminfichierbis;
structurebis[hi2].cheminfichierbis = structurebis[0].temporairebis;
//tri nom fichier
structurebis[0].temporairebis = structurebis[mid2].fichierbasebis;
structurebis[mid2].fichierbasebis = structurebis[hi2].fichierbasebis;
structurebis[hi2].fichierbasebis = structurebis[0].temporairebis;
//tri taille fichier
structurebis[0].temporairebis = structurebis[mid2].taillefichierbis;
structurebis[mid2].taillefichierbis = structurebis[hi2].taillefichierbis;
structurebis[hi2].taillefichierbis = structurebis[0].temporairebis;
//tri date fichier
structurebis[0].temporairebis = structurebis[mid2].datefichierbis;
structurebis[mid2].datefichierbis = structurebis[hi2].datefichierbis;
structurebis[hi2].datefichierbis = structurebis[0].temporairebis;
//tri heure fichier
structurebis[0].temporairebis = structurebis[mid2].heurefichierbis;
structurebis[mid2].heurefichierbis = structurebis[hi2].heurefichierbis;
structurebis[hi2].heurefichierbis = structurebis[0].temporairebis;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "valeur de mid:\t%d\t valeur de hi:\t\%dn",mid,hi);
//fclose(dossieressaibis);
}
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "voici le loguy2 = lo2: \t%d et le higuy2 = hi2:\t%d\t et le mid2: %d \n",loguy2,higuy2,mid2);
//fclose(dossieressaibis);
for(;;) {
if(mid2 > loguy2) {
do {
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "liste des elements dans do\n ");
//fclose(dossieressaibis);
//for (int yeah = lo2; yeah < hi2;yeah++)
//{
//AnsiString baseselection = structurebis[yeah].fichierbasebis.c_str();
//AnsiString textebasedonneese = structure[yeah].fichierbase.c_str();
//fprintf (dossieressaibis, "liste des elements dans do %d\t%s\n",yeah,structure[yeah].fichierbase.c_str());
//}
//fclose(dossieressaibis);
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "voici le loguy 0 MID > LOGUY\t%d\t contenu de loguy:\t%s\t valeur de mid: \t%d\t contenu de mid:\t%s\n",loguy2,structurebis[loguy2].fichierbasebis.c_str(),mid2,structurebis[mid2].fichierbasebis.c_str());
//fclose(dossieressaibis);
loguy2++;//loguy += FULLVL;
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "voici le loguy 1 MID > LOGUY\t%d\t contenu de loguy:\t%s\t valeur de mid: \t%d\t contenu de mid:\t%s \n",loguy2,structurebis[loguy2].fichierbasebis.c_str(),mid2,structurebis[mid2].fichierbasebis.c_str());
// fclose(dossieressaibis);
// MessageBox(NULL,"ca bug??","a oui ca bug",MB_ICONSTOP);
//fermeture de do
} while (loguy2 < mid2 && strcmp(structurebis[loguy2].fichierbasebis.c_str(),structurebis[mid2].fichierbasebis.c_str())<= 0);
//fermeture de if(mid > loguy)
}
// if(mid <= loguy) { //attention s'agit-il bien de loguy??????
if(mid2 <= loguy2) {
do {
loguy2 ++;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "voici le loguy 2 MID <= LOGUY \t%d\t contenu de loguy:\t%s\t valeur de mid: \t%d\t contenu de mid:\t%s \n",loguy,structure[loguy].fichierbase.c_str(),mid,structure[mid].fichierbase.c_str());
//fclose(dossieressaibis);
//MessageBox(NULL,"ca bug8??","a oui ca bug",MB_ICONSTOP);
//fermeture de do
} while(loguy2 <= hi2 && strcmp(structurebis[loguy2].fichierbasebis.c_str(),structurebis[mid2].fichierbasebis.c_str())<= 0);
// fermeture de if (mid <= loguy)
}
do {
higuy2 --;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "voici le higuy 1 \t%d\t contenu de higuy: \t%s\t valeur de mid: \t%d\t contenu de mid:\t%s\n",higuy,structure[higuy].fichierbase.c_str(),mid,structure[mid].fichierbase.c_str());
//fclose(dossieressaibis);
//fermeture de do
} while (higuy2 > mid2 && strcmp(structurebis[higuy2].fichierbasebis.c_str(),structurebis[mid2].fichierbasebis.c_str())> 0);
if(higuy2 < loguy2) break;
//inversion chemin fichier
structurebis[0].temporairebis = structurebis[loguy2].cheminfichierbis;
structurebis[loguy2].cheminfichierbis = structurebis[higuy2].cheminfichierbis;
structurebis[higuy2].cheminfichierbis = structurebis[0].temporairebis;
//inversion nom fichier
structurebis[0].temporairebis = structurebis[loguy2].fichierbasebis;
structurebis[loguy2].fichierbasebis = structurebis[higuy2].fichierbasebis;
structurebis[higuy2].fichierbasebis = structurebis[0].temporairebis;
//inversion taille fichier
structurebis[0].temporairebis = structurebis[loguy2].taillefichierbis;
structurebis[loguy2].taillefichierbis = structurebis[higuy2].taillefichierbis;
structurebis[higuy2].taillefichierbis = structurebis[0].temporairebis;
//inversion date fichier
structurebis[0].temporairebis = structurebis[loguy2].datefichierbis;
structurebis[loguy2].datefichierbis = structurebis[higuy2].datefichierbis;
structurebis[higuy2].datefichierbis = structurebis[0].temporairebis;
//inversion heure fichier
structurebis[0].temporairebis = structurebis[loguy2].heurefichierbis;
structurebis[loguy2].heurefichierbis = structurebis[higuy2].heurefichierbis;
structurebis[higuy2].heurefichierbis = structurebis[0].temporairebis;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "inversion entre loguy et higuy valeur higuy:\t%d\t contenu de higuy: \t%s\t valeur de loguy: \t%d\t contenu de loguy:\t%s\n",higuy,structure[higuy].fichierbase.c_str(),loguy,structure[loguy].fichierbase.c_str());
//fclose(dossieressaibis);
if(mid2 == higuy2) mid2 = loguy2;
//fermeture de for(;;;)
}
higuy2++;
if(mid2 < higuy2) {
do {
higuy2 --;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "voici le higuy 2 mid < higuy \t%d\t contenu de higuy: \t%s\t valeur de mid: \t%d\t contenu de mid:\t%s\n",higuy,structure[higuy].fichierbase.c_str(),mid,structure[mid].fichierbase.c_str());
//fclose(dossieressaibis);
//fermeture de do
} while(higuy2 > mid2 && strcmp(structurebis[higuy2].fichierbasebis.c_str(),structurebis[mid2].fichierbasebis.c_str()) == 0);
//fermeture de if(mid<higuy)
}
if(mid2 >= higuy2) {
do {
higuy2 --;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "voici le higuy 3 mid >= higuy \t%d\t contenu de higuy: \t%s\t valeur de mid: \t%d\t contenu de mid:\t%s\n",higuy,structure[higuy].fichierbase.c_str(),mid,structure[mid].fichierbase.c_str());
//fclose(dossieressaibis);
//for (int yeah = 0; yeah < lignedix-1;yeah++) {
//for (int yeah = 0; yeah < lignetableaubis-1;yeah++) {
//for (int yeah = 0; yeah < lignebis-1;yeah++) {
//AnsiString textebasedonneese = structure[yeah].fichierbase.c_str();
//fprintf (dossieressaibis, "%d\t%s\n",yeah,structure[yeah].fichierbase.c_str());
//}
//fclose(dossieressaibis);
//fermeture de do
} while(higuy2 > lo2 && strcmp(structurebis[higuy2].fichierbasebis.c_str(),structurebis[mid2].fichierbasebis.c_str()) == 0);
//fermeture de if(mid>=higuy)
}
if(higuy2 - lo2 >= hi2 - loguy2) {
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "(higuy - lo >= hi - loguy)\t valeur de higuy:\t%d\t valeur de lo:\t%d\t valeur de hi:\t%d\t valeur de loguy:\t%d\n",higuy,lo,hi,loguy);
//fclose(dossieressaibis);
if(lo2 < higuy2) {
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "(lo < higuy\n");
//fclose(dossieressaibis);
lostk2[stkptr2] = lo2;
histk2[stkptr2] = higuy2;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "(valeur stkptr:\t%d\t lostk[stkptr]: \t%d\t histk[stkptr]:\t%d\n",stkptr,lostk[stkptr],histk[stkptr]);
//fclose(dossieressaibis);
++stkptr2;
//fermeture de if(lo < higuy)
} /* save big recursion for later */
if(loguy2 < hi2) {
lo2 = loguy2;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "(loguy < hi\t valeur de lo: %d\t valeur de loguy\t%d\t valeur de hi\t%d\n",lo,loguy,hi);
//fclose(dossieressaibis);
// MessageBox(NULL,"Alors la on recurse","pour le premier",MB_ICONSTOP);
goto recurse2; /* do small recursion */
//fermeture de if (loguy<hi)
}
} //EXISTE DANS LA VERSION ORIGINALE MAIS NE COMPILE PAS AVEC
else {
if(loguy2 < hi2) {
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "(loguy < hi\n");
//fclose(dossieressaibis);
lostk2[stkptr2] = loguy2;
histk2[stkptr2] = hi2;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "(valeur stkptr:\t%d\t lostk[stkptr]: \t%d\t histk[stkptr]:\t%d\n",stkptr,lostk[stkptr],histk[stkptr]);
//fclose(dossieressaibis);
++stkptr2; /* save big recursion for later */
//fermeture de loguy < hi
}
if(lo2 < higuy2) {
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "(lo < higuy\n");
//fclose(dossieressaibis);
hi2 = higuy2;
// MessageBox(NULL,"Alors la on recurse","pour le second",MB_ICONSTOP);
goto recurse2; /* do small recursion */
//fermeture de if(lo<higuy)
}
//fermeture de else
}
goSTACK2:
if(--stkptr2 >= 0) {
lo2 = lostk2[stkptr2];
hi2 = histk2[stkptr2];
//MessageBox(NULL,"Alors la on recurse","pour le troisième",MB_ICONSTOP);
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "on recurse juste avant la sortie\n");
//fclose(dossieressaibis);
goto recurse2; /* pop subarray from stack */
// fermeture de if(--stkptr >= 0)
}
// } EXISTE DANS LA VERSION ORIGINALE MAIS NE COMPILE PAS AVEC
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "sortie du programme\n");
// fclose(dossieressaibis);
//fermeture de (higuy - lo >= hi - loguy)
//}
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "sortie du programme bis\n");
//fclose(dossieressaibis);
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "********liste après tri de la base de données de référence**********\n");
//fprintf (dossieressaibis, "valeur de hi2: %d\t valeur de mid2: %d\t valeur de lignebis: %d\n",hi2,mid2,lignebis);
//************************************************************************************************************
//************************************************************************************************************
//************************************************************************************************************
//fclose(dossieressaibis);
//for (int yeah = 0; yeah < lignetableaubis-3;yeah++) {
//for (int yeah = 0; yeah < lignebis-3;yeah++) {
//AnsiString textebasedonneese = structurebis[yeah].fichierbasebis.c_str();
// MessageBox(NULL,"le tri est fini de la base du lecteur selectionné","on va le lister",MB_ICONINFORMATION);
//ShowMessage(yeah);
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "%d\t%s\t%s\t\n",yeah,textebasedonneese,structurebis[yeah].cheminfichierbis);
//}
//fclose(dossieressaibis);
//************************************************************************************************************
//************************************************************************************************************
//************************************************************************************************************
//***************************************************************************************************************
//**************fin de la partie de la quatrième méthode*********************************************************
//***************************************************************************************************************
//***************************************************************************************************************
/////essai pour le tri du second tableau dynamique
//********************************************************************************
//********************************************************************************
//***************************************************************************************************************
//**************début de la partie de la seconde méthode*********************************************************
//***************************************************************************************************************
//int numerolignesecond;
//int lignereferencesecond;
//for (int taquator = 0; taquator < lignetableaubis;taquator++)
//{
//lignereferencesecond = taquator;
//for (int tacinq = taquator+1; tacinq < lignetableaubis;tacinq++)
//for (int tacinq = taquator+1; tacinq < lignetableaubis-1;tacinq++)
//{
//if (structurebis[tacinq].fichierbasebis < structurebis[lignereferencesecond].fichierbasebis)
//{
//lignereferencesecond = tacinq;
//}
//}
//if (lignereferencesecond > taquator)
//{
//tri chemin fichier
//structurebis[0].temporairebis = structurebis[taquator].cheminfichierbis;
//structurebis[taquator].cheminfichierbis = structurebis[lignereferencesecond].cheminfichierbis;
//structurebis[lignereferencesecond].cheminfichierbis = structurebis[0].temporairebis;
//tri nom fichier
//structurebis[0].temporairebis = structurebis[taquator].fichierbasebis;
//structurebis[taquator].fichierbasebis = structurebis[lignereferencesecond].fichierbasebis;
//structurebis[lignereferencesecond].fichierbasebis = structurebis[0].temporairebis;
//tri taille fichier
//structurebis[0].temporairebis = structurebis[taquator].taillefichierbis;
//structurebis[taquator].taillefichierbis = structurebis[lignereferencesecond].taillefichierbis;
//structurebis[lignereferencesecond].taillefichierbis = structurebis[0].temporairebis;
//tri date fichier
//structurebis[0].temporairebis = structurebis[taquator].datefichierbis;
//structurebis[taquator].datefichierbis = structurebis[lignereferencesecond].datefichierbis;
//structurebis[lignereferencesecond].datefichierbis = structurebis[0].temporairebis;
//tri heure fichier
//structurebis[0].temporairebis = structurebis[taquator].heurefichierbis;
//structurebis[taquator].heurefichierbis = structurebis[lignereferencesecond].heurefichierbis;
//structurebis[lignereferencesecond].heurefichierbis = structurebis[0].temporairebis;
//}
//}
//MessageBox(NULL,"tri seconde méthode de la base de reference terminé","tri base ok",MB_ICONSTOP);
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "tri fichier base du dossier selectionné tri par nom\n");
//fclose(dossieressaibis);
//***************************************************************************************************************
//**************fin de la partie de la seconde méthode***********************************************************
//***************************************************************************************************************
//***************************************************************************************************************
//***************************************************************************************************************
//***************************************************************************************************************
//**************tri des trois autres parties de la base de données***********************************************
//***************************************************************************************************************
//***************************************************************************************************************
//**************en premier on commence par la date***************************************************************
int NS7,nomsuivant6,tailleordre3,tailleordre3bis,memenom5,dateordre5;
//for (memenom5=0;memenom5<lignetableaubis;memenom5++)
for (memenom5=0;memenom5<lignetableaubis-1;memenom5++)
{
dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
fprintf (dossieressaibis, "memenom5:\t%d nom fichier\t%s\tmemenom5+1:%d\tnom fichier suivant:%s\n",memenom5,structurebis[memenom5].fichierbasebis.c_str(),memenom5+1,structurebis[memenom5+1].fichierbasebis.c_str());
fclose(dossieressaibis);
if (structurebis[memenom5].fichierbasebis == structurebis[memenom5+1].fichierbasebis)
{
nomsuivant6 = 1;
//dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
//fprintf (dossieressaibis, "memenom5:\t%dnom fichier\t%s\tmemenom5+1:%d\tnom fichier suivant:%s\n",memenom5,structurebis[memenom5].fichierbasebis.c_str(),memenom5+1,structurebis[memenom5+1].fichierbasebis.c_str());
//fclose(dossieressaibis);
// do
NS7 = strcmp(structurebis[memenom5].fichierbasebis.c_str(),structurebis[memenom5+nomsuivant6].fichierbasebis.c_str());
while (NS7 == 0 && memenom5+nomsuivant6 < lignetableaubis)
{
NS7 = strcmp(structurebis[memenom5].fichierbasebis.c_str(),structurebis[memenom5+nomsuivant6].fichierbasebis.c_str());
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "structure lecteur memenom5:\t%dnom fichier\t%s\tmemenom5+nom suivant:%d\tnom fichier suivant:%s\n",memenom5,structurebis[memenom5].fichierbasebis.c_str(),memenom5+nomsuivant6,structurebis[memenom5+nomsuivant6].fichierbasebis.c_str());
// fclose(dossieressaibis);
nomsuivant6++;
NS7 = strcmp(structurebis[memenom5].fichierbasebis.c_str(),structurebis[memenom5+nomsuivant6].fichierbasebis.c_str());
}//while(NS7 == 0 && memenom5+nomsuivant6 < lignetableaubis);
for (dateordre5 = memenom5; dateordre5 < memenom5+nomsuivant6;dateordre5++)
{
int lignereferencequar = dateordre5;
for (int dateordre5bis = dateordre5+1; dateordre5bis < memenom5+nomsuivant6;dateordre5bis++)
{
if (structurebis[dateordre5bis].datefichierbis < structurebis[lignereferencequar].datefichierbis)
{
lignereferencequar = dateordre5bis;
}
}
if (lignereferencequar > dateordre5)
{
//tri chemin fichier
structurebis[0].temporairebis = structurebis[dateordre5].cheminfichierbis;
structurebis[dateordre5].cheminfichierbis = structurebis[lignereferencequar].cheminfichierbis;
structurebis[lignereferencequar].cheminfichierbis = structurebis[0].temporairebis;
//tri nom fichier
structurebis[0].temporairebis = structurebis[dateordre5].fichierbasebis;
structurebis[dateordre5].fichierbasebis = structurebis[lignereferencequar].fichierbasebis;
structurebis[lignereferencequar].fichierbasebis = structurebis[0].temporairebis;
//tri taille fichier
structurebis[0].temporairebis = structurebis[dateordre5].taillefichierbis;
structurebis[dateordre5].taillefichierbis = structurebis[lignereferencequar].taillefichierbis;
structurebis[lignereferencequar].taillefichierbis = structurebis[0].temporairebis;
//tri date fichier
structurebis[0].temporairebis = structurebis[dateordre5].datefichierbis;
structurebis[dateordre5].datefichierbis = structurebis[lignereferencequar].datefichierbis;
structurebis[lignereferencequar].datefichierbis = structurebis[0].temporairebis;
//tri heure fichier
structurebis[0].temporairebis = structurebis[dateordre5].heurefichierbis;
structurebis[dateordre5].heurefichierbis = structurebis[lignereferencequar].heurefichierbis;
structurebis[lignereferencequar].heurefichierbis = structurebis[0].temporairebis;
}
}
//sortie de if structurebis[memenom5].fichierbasebis == structurebis[memenom5+1].fichierbasebis)
}
//sortie de for (memenom5=0;memenom5<lignetableaubis;memenom5++)
}
//********puis on continue par l'heure du fichier*******************************
//int NS1,nomsuivant1,tailleordre,tailleordrebis,memenom7,heureordre;
int NS8,nomsuivant8,memenom7,heureordreqar,NS9;
//for (memenom7=0;memenom7<lignetableaubis;memenom7++)
for (memenom7=0;memenom7<lignetableaubis-1;memenom7++)
{
if (structurebis[memenom7].fichierbasebis == structurebis[memenom7+1].fichierbasebis && structurebis[memenom7].datefichierbis == structurebis[memenom7+1].datefichierbis)
{
nomsuivant8 = 0;
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "tri heure memenom7:\t%dnom fichier\t%s\tdate fichier: %s\tmemenom7+1:%d\tnom fichier suivant:%s\tdate fichier suivant: %s\n",memenom7,structurebis[memenom7].fichierbasebis.c_str(),structurebis[memenom7].datefichierbis.c_str(),memenom7+1,structurebis[memenom7+1].fichierbasebis.c_str(),structurebis[memenom7+1].datefichierbis.c_str());
// fclose(dossieressaibis);
NS8 = strcmp(structurebis[memenom7].fichierbasebis.c_str(),structurebis[memenom7+nomsuivant8].fichierbasebis.c_str());
NS9 = strcmp(structurebis[memenom7].datefichierbis.c_str(),structurebis[memenom7+nomsuivant8].datefichierbis.c_str());
while (NS8 == 0 && NS9 == 0 && memenom7+nomsuivant8 < lignetableaubis)
// do
{
// NS8 = strcmp(structurebis[memenom7].fichierbasebis.c_str(),structurebis[memenom7+nomsuivant8].fichierbasebis.c_str());
// NS9 = strcmp(structurebis[memenom7].datefichierbis.c_str(),structurebis[memenom7+nomsuivant8].datefichierbis.c_str());
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "boucle do de heure memenom7:\t%dnom fichier:\t%s\tdate fichier:\t%s\theure fichier:%s\tmemenom7+nom suivant:%d\tnom fichier suivant:%s\tdate fichier:%s\theure fichier:\t%s\n",memenom7,structurebis[memenom7].fichierbasebis.c_str(),structurebis[memenom7].datefichierbis.c_str(),structurebis[memenom7].heurefichierbis.c_str(),memenom7+nomsuivant8,structurebis[memenom7+nomsuivant8].fichierbasebis.c_str(),structurebis[memenom7+nomsuivant8].datefichierbis.c_str(),structurebis[memenom7+nomsuivant8].heurefichierbis.c_str());
// fclose(dossieressaibis);
nomsuivant8++;
NS8 = strcmp(structurebis[memenom7].fichierbasebis.c_str(),structurebis[memenom7+nomsuivant8].fichierbasebis.c_str());
NS9 = strcmp(structurebis[memenom7].datefichierbis.c_str(),structurebis[memenom7+nomsuivant8].datefichierbis.c_str());
}
for (heureordreqar = memenom7; heureordreqar < memenom7+nomsuivant8;heureordreqar++)
{
int lignereferencebis = heureordreqar;
//for (int heureordreqarbis = heureordreqar+1; heureordreqarbis < memenom7+nomsuivant8;heureordreqarbis++)
for (int heureordreqarbis = heureordreqar+1; heureordreqarbis < memenom7+nomsuivant8;heureordreqarbis++)
{
if (structurebis[heureordreqarbis].heurefichierbis < structurebis[lignereferencebis].heurefichierbis)
{
lignereferencebis = heureordreqarbis;
//lignereferencebis = heureordreqar;
}
}
if (lignereferencebis > heureordreqar)
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "*****permutation section heure valeur lignerefencebis:%d\tvaleur heureordreqar:\t%d\nalors la on permute memenom7:\t%dnom fichier\t%s\tdate fichier\t%s\tmemenom7+nom suivant:%d\tnom fichier suivant:%s\tdate fichier:%s\n",lignereferencebis,heureordreqar,lignereferencebis,structurebis[lignereferencebis].fichierbasebis.c_str(),structurebis[lignereferencebis].datefichierbis.c_str(),heureordreqar,structurebis[heureordreqar].fichierbasebis.c_str(),structurebis[heureordreqar].datefichierbis.c_str());
// fclose(dossieressaibis);
{
//tri chemin fichier
structurebis[0].temporairebis = structurebis[heureordreqar].cheminfichierbis;
structurebis[heureordreqar].cheminfichierbis = structurebis[lignereferencebis].cheminfichierbis;
structurebis[lignereferencebis].cheminfichierbis = structurebis[0].temporairebis;
//tri nom fichier
structurebis[0].temporairebis = structurebis[heureordreqar].fichierbasebis;
structurebis[heureordreqar].fichierbasebis = structurebis[lignereferencebis].fichierbasebis;
structurebis[lignereferencebis].fichierbasebis = structurebis[0].temporairebis;
//tri taille fichier
structurebis[0].temporairebis = structurebis[heureordreqar].taillefichierbis;
structurebis[heureordreqar].taillefichierbis = structurebis[lignereferencebis].taillefichierbis;
structurebis[lignereferencebis].taillefichierbis = structurebis[0].temporairebis;
//tri date fichier
structurebis[0].temporairebis = structurebis[heureordreqar].datefichierbis;
structurebis[heureordreqar].datefichierbis = structurebis[lignereferencebis].datefichierbis;
structurebis[lignereferencebis].datefichierbis = structurebis[0].temporairebis;
//tri heure fichier
structurebis[0].temporairebis = structurebis[heureordreqar].heurefichierbis;
structurebis[heureordreqar].heurefichierbis = structurebis[lignereferencebis].heurefichierbis;
structurebis[lignereferencebis].heurefichierbis = structurebis[0].temporairebis;
}
}
//sortie de if structurebis[memenom1].fichierbasebis == structurebis[memenom1+1].fichierbasebis)
}
//sortie de for (memenom1=0;memenom1<lignetableaubis;memenom1++)
}
//*******enfin pour finir la taille*********************************************
int NS10,nomsuivant10,memenom10,tailleordreqar,NS11,NS12;
//for (memenom10=0;memenom10<lignetableaubis;memenom10++)
for (memenom10=0;memenom10<lignetableaubis-1;memenom10++)
{
if (structurebis[memenom10].fichierbasebis == structurebis[memenom10+1].fichierbasebis && structurebis[memenom10].datefichierbis == structurebis[memenom10+1].datefichierbis &&structurebis[memenom10].heurefichierbis == structurebis[memenom10+1].heurefichierbis )
{
nomsuivant10 = 0;
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "tri taille memenom10:\t%dnom fichier\t%s\tdate fichier: %s\tmemenom10+1:%d\tnom fichier suivant:%s\tdate fichier suivant: %s\n",memenom10,structurebis[memenom10].fichierbasebis.c_str(),structurebis[memenom10].datefichierbis.c_str(),memenom10+1,structurebis[memenom10+1].fichierbasebis.c_str(),structurebis[memenom10+1].datefichierbis.c_str());
// fclose(dossieressaibis);
NS10 = strcmp(structurebis[memenom10].fichierbasebis.c_str(),structurebis[memenom10+nomsuivant10].fichierbasebis.c_str());
NS11 = strcmp(structurebis[memenom10].datefichierbis.c_str(),structurebis[memenom10+nomsuivant10].datefichierbis.c_str());
NS12 = strcmp(structurebis[memenom10].heurefichierbis.c_str(),structurebis[memenom10+nomsuivant10].heurefichierbis.c_str());
// do
while(NS10 == 0 && NS11 == 0 && NS12 == 0 && memenom10+nomsuivant10 < lignetableaubis)
{
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "boucle do de taille memenom10:\t%dnom fichier\t%s\tdate fichier\t%s\t\heure fichier:%s\tmemenom10+nom suivant:%d\tnom fichier suivant:%s\tdate fichier:%s\t\heure fichier:%s\n",memenom10,structurebis[memenom10].fichierbasebis.c_str(),structurebis[memenom10].datefichierbis.c_str(),structurebis[memenom10].heurefichierbis.c_str(),memenom10+nomsuivant10,structurebis[memenom10+nomsuivant10].fichierbasebis.c_str(),structurebis[memenom10+nomsuivant10].datefichierbis.c_str(),structurebis[memenom10+nomsuivant10].heurefichierbis.c_str());
// fclose(dossieressaibis);
nomsuivant10++;
NS10 = strcmp(structurebis[memenom10].fichierbasebis.c_str(),structurebis[memenom10+nomsuivant10].fichierbasebis.c_str());
NS11 = strcmp(structurebis[memenom10].datefichierbis.c_str(),structurebis[memenom10+nomsuivant10].datefichierbis.c_str());
NS12 = strcmp(structurebis[memenom10].heurefichierbis.c_str(),structurebis[memenom10+nomsuivant10].heurefichierbis.c_str());
}//while(NS10 == 0 && NS11 == 0 && NS12 == 0 && memenom10+nomsuivant10 < lignetableaubis);
for (tailleordreqar = memenom10; tailleordreqar < memenom10+nomsuivant10;tailleordreqar++)
{
int lignereferencebis = tailleordreqar;
//for (int tailleordreqarbis = tailleordreqar+1; tailleordreqarbis < memenom10+nomsuivant10;tailleordreqarbis++)
for (int tailleordreqarbis = tailleordreqar+1; tailleordreqarbis < memenom10+nomsuivant10;tailleordreqarbis++)
{
if (structurebis[tailleordreqarbis].taillefichierbis < structurebis[lignereferencebis].taillefichierbis)
{
lignereferencebis = tailleordreqarbis;
//lignereferencebis = tailleordreqar;
}
}
if (lignereferencebis > tailleordreqar)
// dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
// fprintf (dossieressaibis, "alors la on permute memenom10:\t%dnom fichier\t%s\tdate fichier\t%s\tmemenom10+nom suivant:%d\tnom fichier suivant:%s\tdate fichier:%s\n",lignereferencebis,structurebis[lignereferencebis].fichierbasebis.c_str(),structurebis[lignereferencebis].datefichierbis.c_str(),tailleordreqar,structurebis[tailleordreqar].fichierbasebis.c_str(),structurebis[tailleordreqar].datefichierbis.c_str());
// fclose(dossieressaibis);
{
//tri chemin fichier
structurebis[0].temporairebis = structurebis[tailleordreqar].cheminfichierbis;
structurebis[tailleordreqar].cheminfichierbis = structurebis[lignereferencebis].cheminfichierbis;
structurebis[lignereferencebis].cheminfichierbis = structurebis[0].temporairebis;
//tri nom fichier
structurebis[0].temporairebis = structurebis[tailleordreqar].fichierbasebis;
structurebis[tailleordreqar].fichierbasebis = structurebis[lignereferencebis].fichierbasebis;
structurebis[lignereferencebis].fichierbasebis = structurebis[0].temporairebis;
//tri taille fichier
structurebis[0].temporairebis = structurebis[tailleordreqar].taillefichierbis;
structurebis[tailleordreqar].taillefichierbis = structurebis[lignereferencebis].taillefichierbis;
structurebis[lignereferencebis].taillefichierbis = structurebis[0].temporairebis;
//tri date fichier
structurebis[0].temporairebis = structurebis[tailleordreqar].datefichierbis;
structurebis[tailleordreqar].datefichierbis = structurebis[lignereferencebis].datefichierbis;
structurebis[lignereferencebis].datefichierbis = structurebis[0].temporairebis;
//tri heure fichier
structurebis[0].temporairebis = structurebis[tailleordreqar].heurefichierbis;
structurebis[tailleordreqar].heurefichierbis = structurebis[lignereferencebis].heurefichierbis;
structurebis[lignereferencebis].heurefichierbis = structurebis[0].temporairebis;
}
}
//sortie de if structure[memenom2].fichierbase == structure[memenom2+1].fichierbase)
}
//sortie de for (memenom2=0;memenom2<lignedix;memenom2++)
}
//*********fin tri des autres elements
int stop7 = (GetTickCount() - start7)/1000;
char temps7[150];
sprintf(temps7,"Tri de la base de données du dossier séléctionné terminé en : %d s",stop7);
Form1->Label15->Caption = temps7;
Application->ProcessMessages();
//listage de la base de données du lecteur ou fichier à comparer
dossieressaibis = fopen("c:\\pouressai\\fichieressaibis.xrdb","a");
fprintf (dossieressaibis, "\n\n*****************premier tri par taille de la base du lecteur ou fichier à tester*****************\n");
for (int yeah = 0; yeah < lignetableaubis-1;yeah++) {
AnsiString textebasedonneese = structurebis[yeah].fichierbasebis.c_str();
fprintf (dossieressaibis, "%d\t%s\tdate fichier: %s\t heure fichier: %s\ttaillefichier: %s\n",yeah,textebasedonneese,structurebis[yeah].datefichierbis.c_str(),structurebis[yeah].heurefichierbis.c_str(),structurebis[yeah].taillefichierbis.c_str());
}
fclose(dossieressaibis);
//////fin essai pour le tri du second tableau dynamique
//****************************************************************************************
//****************************************************************************************
int start8 = GetTickCount();
Form1->Label17->Caption = "Affichage du résultat en cours:";
Form1->Label17->Visible = true;
Form1->ListView1->Visible = true;
Form1->ProgressBar1->Visible = true;
Form1->ProgressBar1->Min = 0;
Form1->ProgressBar1->Max = lignetableaubis;
//Sleep(100);
TListColumn *NewColumn;
TListItem *ListItem;
// TListView *ListView = new TListView(this);
Form1->ListView1->Align = alNone;
Form1->ListView1->ViewStyle = vsReport;
if (cliqueb2 < 2)
{
NewColumn = Form1->ListView1->Columns->Add();
NewColumn->Caption = "Chemin fichier";
NewColumn = Form1->ListView1->Columns->Add();
NewColumn->Caption = "Nom fichier";
NewColumn = Form1->ListView1->Columns->Add();
NewColumn->Caption = "date";
NewColumn = Form1->ListView1->Columns->Add();
NewColumn->Caption = "heure";
NewColumn = Form1->ListView1->Columns->Add();
NewColumn->Caption = "taille";
NewColumn = Form1->ListView1->Columns->Add();
NewColumn->Caption = "hors ou dans la base";
}
dossierdoublon = fopen("c:\\pouressai\\fichierdoublon.xrdb","a");
dossiernomdifferent = fopen("c:\\pouressai\\fichierhorsdelabase.xrdb","wt");
dossieressai = fopen("c:\\pouressai\\fichieressai.xrdb","a");
//fin création de la base de donnees selectionnee a verifier
//******************************************************************************
//******************************************************************************
//maintenant que les deux tableaux dynamiques sont faits on liste pour
// la comparaison des deux fichiers.
//essai pour avoir tous les fichiers du lecteur selectionné
int pointeur= 0;
for (int testlecture = 0; testlecture< lignetableaubis;testlecture++)
{
Form1->ProgressBar1->Position = testlecture;
for (pointeur;pointeur<= lignetableau+1;pointeur++)
{
//les fichiers en tout point identiques sont enlevé pour ne garder que le premier
if (pointeur > 0)
{
AnsiString testficher11 = structure[pointeur].fichierbase.c_str();
AnsiString testficher21 = structure[pointeur-1].fichierbase.c_str();
AnsiString testdate11 = structure[pointeur].datefichier.c_str();
AnsiString testdate21 = structure[pointeur-1].datefichier.c_str();
AnsiString testheure11 = structure[pointeur].heurefichier.c_str();
AnsiString testheure21 = structure[pointeur-1].heurefichier.c_str();
AnsiString testtaille11 = structure[pointeur].taillefichier.c_str();
AnsiString testtaille21 = structure[pointeur-1].taillefichier.c_str();
int II = CompareStr(testficher11, testficher21);
int JI = CompareStr(testdate11,testdate21);
int KI = CompareStr(testheure11,testheure21);
int LI = CompareStr(testtaille11,testtaille21);
while (II == 0 && JI == 0 && KI == 0 && LI == 0 && pointeur <= lignetableau+1)
{
//dossieressai = fopen("c:\\pouressai\\fichieressai.xrdb","a");
//fprintf (dossieressai, "2 fichiers identiques base de données: nom fichier:\t%s\t &\t%s\t date fichier:\t%s & %s\theure fichier:\t%s & \t%s\ttaille fichier:\t%s &\t%s\n",structure[pointeur].fichierbase.c_str(),structure[pointeur-1].fichierbase.c_str(),structure[pointeur].datefichier.c_str(),structure[pointeur-1].datefichier.c_str(),structure[pointeur].heurefichier.c_str(),structure[pointeur-1].heurefichier.c_str(),structure[pointeur].taillefichier.c_str(),structure[pointeur-1].taillefichier.c_str());
//fclose(dossieressai);
pointeur++;
AnsiString testficher11 = structure[pointeur].fichierbase.c_str();
AnsiString testficher21 = structure[pointeur-1].fichierbase.c_str();
AnsiString testdate11 = structure[pointeur].datefichier.c_str();
AnsiString testdate21 = structure[pointeur-1].datefichier.c_str();
AnsiString testheure11 = structure[pointeur].heurefichier.c_str();
AnsiString testheure21 = structure[pointeur-1].heurefichier.c_str();
AnsiString testtaille11 = structure[pointeur].taillefichier.c_str();
AnsiString testtaille21 = structure[pointeur-1].taillefichier.c_str();
II = CompareStr(testficher11, testficher21);
JI = CompareStr(testdate11,testdate21);
KI = CompareStr(testheure11,testheure21);
LI = CompareStr(testtaille11,testtaille21);
}
}
//ShowMessage(pointeur)
AnsiString baseselection = structurebis[testlecture].fichierbasebis.c_str();
AnsiString textebasedonnees = structure[pointeur].fichierbase.c_str();
//essai taille fichier
AnsiString taillebaseselection = structurebis[testlecture].taillefichierbis.c_str();
AnsiString tailletextebasedonnees = structure[pointeur].taillefichier.c_str();
//fin essai taille fichier
//essai date fichier
AnsiString datebaseselection = structurebis[testlecture].datefichierbis.c_str();
AnsiString datetextebasedonnees =structure[pointeur].datefichier.c_str();
//fin essai date fichier
//essai heure fichier
AnsiString heurebaseselection = structurebis[testlecture].heurefichierbis.c_str();
AnsiString heuretextebasedonnees = structure[pointeur].heurefichier.c_str();
//fin essai heure fichier
//MessageBox(NULL,structurebis[testlecture].fichierbasebis.c_str(),"fichier relus référence",MB_ICONSTOP);
//ShowMessage (testlecture);
//MessageBox(NULL,structure[testlecturebis].fichierbase.c_str(),"fichier relus à vérifier",MB_ICONSTOP);
//ShowMessage (testlecturebis);
//fprintf (dossieressai, "%s\t%d\t%s\t%d\n",baseselection,testlecture,textebasedonnees,pointeur);
//Pour voir la comparaison entre la base de séléction et celle de référence
//fprintf (dossieressai, "%s\t%d\t%s\t%s\t%s\t%s\t%d\t%s\t%s\t%s\n",baseselection,testlecture,taillebaseselection,datebaseselection,heurebaseselection,textebasedonnees,pointeur,tailletextebasedonnees,datetextebasedonnees,heuretextebasedonnees);
//ShowMessage(baseselection);
I = CompareStr(baseselection, textebasedonnees); // la valeur de I est < 0
J = CompareStr(taillebaseselection, tailletextebasedonnees);
K = CompareStr(datebaseselection, datetextebasedonnees);
L = CompareStr(heurebaseselection, heuretextebasedonnees);
char baseselectionbis[500];
char textebasedonneesbis[500];
sprintf(baseselectionbis,"%s",baseselection);
sprintf(textebasedonneesbis,"%s",textebasedonnees);
//MessageBox(NULL,baseselectionbis,"fichier relus selection 1",MB_ICONSTOP);
//MessageBox(NULL,textebasedonneesbis,"fichier relus base donnees 2",MB_ICONSTOP);
// ShowMessage ("Les chaînes ne sont pas identiques");
if (I == 0 && J == 0 && K == 0 && L == 0)
{
//nbfichiertotal correspond au nombre de fichier dans le lecteur ou fichier à comparer
nbfichiertotal++;
nbfichieridentique++;
ListItem = Form1->ListView1->Items->Add();
ListItem->Caption = structurebis[testlecture].cheminfichierbis.c_str();
ListItem->SubItems->Add(structurebis[testlecture].fichierbasebis.c_str());
ListItem->SubItems->Add(structurebis[testlecture].datefichierbis.c_str());
ListItem->SubItems->Add(structurebis[testlecture].heurefichierbis.c_str());
ListItem->SubItems->Add(structurebis[testlecture].taillefichierbis.c_str());
ListItem->SubItems->Add("dans la base");
sprintf(baseselectionbis,"%s",taillebaseselection);
sprintf(textebasedonneesbis,"%s",tailletextebasedonnees);
//fprintf (dossierdoublon, "%d\t%s\t%s\t%s\t%s\n",nbfichiertotal,baseselection,taillebaseselection,datebaseselection,heurebaseselection);
break;
}
//if (I < 0)
if (I < 0 && testlecture < (lignetableaubis-1))
{
nbfichiertotal++;
nbfichierdifferent++;
fprintf (dossiernomdifferent, "%s\t%s\t%s\t%s\n",baseselection,taillebaseselection,datebaseselection,heurebaseselection);
//fprintf (dossiernomdifferent, "%s\t%s\t%s\t%s\n",textebasedonnees,tailletextebasedonnees,datetextebasedonnees,heuretextebasedonnees);
ListItem = Form1->ListView1->Items->Add();
ListItem->Caption = structurebis[testlecture].cheminfichierbis.c_str();
ListItem->SubItems->Add(structurebis[testlecture].fichierbasebis.c_str());
ListItem->SubItems->Add(structurebis[testlecture].datefichierbis.c_str());
ListItem->SubItems->Add(structurebis[testlecture].heurefichierbis.c_str());
ListItem->SubItems->Add(structurebis[testlecture].taillefichierbis.c_str());
ListItem->SubItems->Add("**hors de la base**");
break;
}
if (I > 0 && pointeur == lignetableau && testlecture < (lignetableaubis-1))
{
nbfichiertotal++;
nbfichierdifferent++;
fprintf (dossiernomdifferent, "%s\t%s\t%s\t%s\n",baseselection,taillebaseselection,datebaseselection,heurebaseselection);
//fprintf (dossiernomdifferent, "%s\t%s\t%s\t%s\n",textebasedonnees,tailletextebasedonnees,datetextebasedonnees,heuretextebasedonnees);
ListItem = Form1->ListView1->Items->Add();
ListItem->Caption = structurebis[testlecture].cheminfichierbis.c_str();
ListItem->SubItems->Add(structurebis[testlecture].fichierbasebis.c_str());
ListItem->SubItems->Add(structurebis[testlecture].datefichierbis.c_str());
ListItem->SubItems->Add(structurebis[testlecture].heurefichierbis.c_str());
ListItem->SubItems->Add(structurebis[testlecture].taillefichierbis.c_str());
ListItem->SubItems->Add("**hors de la base reference au dessus**");
break;
}
}
Form1->ProgressBar1->Position = 0;
}
Form1->ProgressBar1->Visible = false;
if (nbfichierdifferent < 1) Form1->Label3->Caption = "nombre de fichier manquant";
if (nbfichieridentique < 1) Form1->Label2->Caption = "nombre de fichier doublon";
Form1->Edit1->Visible = true;
Form1->Edit2->Visible = true;
Form1->Edit3->Visible = true;
Form1->Label1->Visible = true;
Form1->Label2->Visible = true;
Form1->Label3->Visible = true;
Form1->ListView1->Visible = true;
Form1->Edit1->Text = nbfichiertotal;
Form1->Edit2->Text = nbfichieridentique;
Form1->Edit3->Text = nbfichierdifferent;
nbfichierdifferent = 0;
nbfichieridentique = 0;
nbfichiertotal = 0;
delete[] structure; //Désallocation
delete[] structurebis; //Désallocation
//MessageBox(NULL,"fin","le listage du fichier est fini",MB_ICONSTOP);
fclose(dossierdoublon);
fclose(dossiernomdifferent);
fclose(dossieressai);
fclose(dossierlist);
//sortie de la fonction remplirtableau
DeleteFile("C:\\pouressai\\fichierzip.bat");
DeleteFile("C:\\pouressai\\supzip.bat");
DeleteFile("C:\\pouressai\\fichieressai.xrdb");
DeleteFile("C:\\pouressai\\fichieressaibis.xrdb");
DeleteFile("C:\\pouressai\\fichierhorsdelabase.xrdb");
DeleteFile("C:\\pouressai\\fichiertemporaire.txt");
DeleteFile("C:\\pouressai\\fichierdoublon.xrdb");
lignetableaubis = 0;
int stop8 = (GetTickCount()-start8)/1000;
char temps8[150];
sprintf(temps8,"Affichage du résultat en %d s",stop8);
Form1->Label17->Caption = temps8;
}
//}
//---------------------------------------------------------------------------
void __fastcall TForm1::ListView1ColumnClick(TObject *Sender,
TListColumn *Column)
{
//contient le numéro de la colonne cliqué -1
ColumnToSort = Column->Index;
if (ColumnToSort == 0)
{
ordre0 = !ordre0;
}
if (ColumnToSort == 1)
{
ordre1 = !ordre1;
}
if (ColumnToSort == 2)
{
ordre2 = !ordre2;
}
if (ColumnToSort == 3)
{
ordre3 = !ordre3;
}
if (ColumnToSort == 4)
{
ordre4= !ordre4;
}
if (ColumnToSort == 5)
{
ordre5= !ordre5;
}
((TCustomListView *)Sender)->AlphaSort();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ListView1Compare(TObject *Sender, TListItem *Item1,
TListItem *Item2, int Data, int &Compare)
{
int ix = (ColumnToSort-1);
// if (ColumnToSort == 0)
if (ColumnToSort == 0 && ordre0 == 0)
Compare = CompareText(Item1->Caption,Item2->Caption);
if (ColumnToSort == 0 && ordre0 == 1)
Compare = CompareText(Item2->Caption,Item1->Caption);
if (ColumnToSort == 1 && ordre1 == 0)
Compare = CompareText(Item1->SubItems->Strings[ix] ,Item2->SubItems->Strings[ix]);
if (ColumnToSort == 1 && ordre1 == 1)
Compare = CompareText(Item2->SubItems->Strings[ix] ,Item1->SubItems->Strings[ix]);
if (ColumnToSort == 2 && ordre2 == 0)
Compare = CompareText(Item1->SubItems->Strings[ix] ,Item2->SubItems->Strings[ix]);
if (ColumnToSort == 2 && ordre2 == 1)
Compare = CompareText(Item2->SubItems->Strings[ix] ,Item1->SubItems->Strings[ix]);
if (ColumnToSort == 3 && ordre3 == 0)
Compare = CompareText(Item1->SubItems->Strings[ix] ,Item2->SubItems->Strings[ix]);
if (ColumnToSort == 3 && ordre3 == 1)
Compare = CompareText(Item2->SubItems->Strings[ix] ,Item1->SubItems->Strings[ix]);
if (ColumnToSort == 4 && ordre4 == 0)
//Compare = CompareText(Item1->SubItems->Strings[ix] ,Item2->SubItems->Strings[ix]);
Compare = CompareText(Item1->SubItems->Strings[ix] ,Item2->SubItems->Strings[ix]);
if (ColumnToSort == 4 && ordre4 == 1)
//Compare = CompareText(Item2->SubItems->Strings[ix] ,Item1->SubItems->Strings[ix]);
Compare = CompareText(Item2->SubItems->Strings[ix] ,Item1->SubItems->Strings[ix]);
if (ColumnToSort == 5 && ordre5 == 0)
Compare = CompareText(Item1->SubItems->Strings[ix] ,Item2->SubItems->Strings[ix]);
if (ColumnToSort == 5 && ordre5 == 1)
Compare = CompareText(Item2->SubItems->Strings[ix] ,Item1->SubItems->Strings[ix]);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ListView1SelectItem(TObject *Sender,
TListItem *Item, bool Selected)
{
if (Form1->ListView1->SelCount > 0)
{
Form1->Edit4->Visible = true;
Form1->Label4->Visible = true;
Form1->Edit4->Text = Form1->ListView1->SelCount;
Form1->Button3->Visible = true;
}
else
{
Form1->Edit4->Visible = false;
Form1->Label4->Visible = false;
Form1->Edit4->Text = Form1->ListView1->SelCount;
Form1->Button3->Visible = false;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
Form1->ProgressBar1->Visible = true;
AnsiString sousnom,concatnom;
TItemStates selected = TItemStates() << isSelected;
TListItem *Item = ListView1->Selected;
TListItem *Item2 = ListView1->Selected;
char nomselec[256];
char nomselec2[256];
int longueur;
ProgressBar1->Position = 0;
int bargraf = StrToInt(Form1->Edit4->Text);
ProgressBar1->Min = 0; ProgressBar1->Max =bargraf;
int compt = 0;
while (Item){
char nomselec3[256] ="";
sousnom = Item2->SubItems->Strings[0];
sprintf(nomselec,"%s",Item->Caption);
sprintf(nomselec2,"%s",Item2->SubItems->Strings[0]);
StrCat(nomselec3,nomselec);
StrCat(nomselec3,"\\");
StrCat(nomselec3,nomselec2);
AnsiString cherzip;
cherzip = Item->Caption;
int espace4 = 0;
espace4 = cherzip.AnsiPos(".zip");
if (espace4 == 0)
{
DeleteFile(nomselec3);
}
if (espace4 > 0)
{
supzip = fopen("c:\\pouressai\\supzip.bat","wt");
fprintf (supzip, "c:\\sevenzip\\7za.exe d \"%s\" \"%s\" -r",nomselec,nomselec2);
fclose(supzip);
system ("c:\\pouressai\\supzip.bat");
}
int selecposition = Item->Index;
if (Item->SubItems->Strings[4] == "**hors de la base**")
{
Form1->Edit3->Text = (Form1->Edit3->Text)-1;
Form1->Edit1->Text = (Form1->Edit1->Text)-1;
}
if (Item->SubItems->Strings[4] == "**hors de la base reference au dessus**")
{
Form1->Edit3->Text = (Form1->Edit3->Text)-1;
Form1->Edit1->Text = (Form1->Edit1->Text)-1;
}
if (Item->SubItems->Strings[4] == "dans la base")
{
Form1->Edit2->Text = (Form1->Edit2->Text)-1;
Form1->Edit1->Text = (Form1->Edit1->Text)-1;
}
Item = ListView1->GetNextItem(Item, sdAll, selected);
Item2 = ListView1->GetNextItem(Item2, sdAll, selected);
ListView1->Items->Delete(selecposition);
compt++;
ProgressBar1->Position = compt;
}
Sleep(5000);
ProgressBar1->Position = 0;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
DeleteFile("C:\\pouressai\\fichierzip.bat");
DeleteFile("C:\\pouressai\\supzip.bat");
DeleteFile("C:\\pouressai\\fichieressai.xrdb");
DeleteFile("C:\\pouressai\\fichieressaibis.xrdb");
DeleteFile("C:\\pouressai\\fichierhorsdelabase.xrdb");
DeleteFile("C:\\pouressai\\fichierdoublon.xrdb");
}
//---------------------------------------------------------------------------
Conclusion :
Si l'on passe du CD-ROM au DVD-ROM alors il est interessant de faire une base des DVD-ROM pour la comparer au CD-ROM pour vérifier que tous les fichiers sont sauvegardés.
Codes Sources
A voir également
- Base de données fichier
- Base de données javascript - Conseils pratiques -Javascript
- Récupérer données json (javascript) - Conseils pratiques -Javascript
- Restauration base de données sql server ✓ - Forum SQL
- Base de données e-commerce - Forum PHP
- Nomenclature base de données - Conseils pratiques -PHP
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.