GESTION FICHIERS TXT (INSERTION, CONCATÉNATION, DÉNOMBREMENT, FILTRES ETC...)

#include <iostream>
#include <vector>

using namespace std;

class LectEcr {

	


private : 

	FILE * f;
	char * nom; 
	
	vector <int> indexDebutMots;	//Table d'indexation de tous les mots (les debuts de mots)
	vector <int> indexFinMots;		//Table d'indexation de tous les mots (les fins de mots)
	vector <int> indexLignes;		//Table d'indexation de toutes les lignes (les debuts):
	
	int nbMots;					//Nombre de mots total (apres passage de la fonction MAJIndex)
	int nbLignes;				//Nombre de lignes total (apres passage de la fonction MAJIndex)

	bool isopen ;
	int mode_open;


public : 

	LectEcr(char * c);			//Constructeur


/////////////////////////////////////////////////////////////////////////
//	Fonctions de Base
/////////////////////////////////////////////////////////////////////////

	//Ecrit la chaine dans le fichier à la position et sur la longueur indiquée
	//Efface les caracteres présents sur ces positions si il le faut
	bool ecrire(char * chaine,int pos,int longueur);  
	
	
	//Lit les caracteres et les place dans le buffer de debut sur la longueur indiquée
	int lire(char * buffer,int deb,int longueur);	   

	//Ouvre le fichier courant
	//mode 1 : "r+" (lecture ecriture) / mode 2 mode concatenation "a"
	bool ouvrir(int mode);

	//Ferme le fichier courant
	int fermer();



/////////////////////////////////////////////////////////////////////////
//	Fonctions de remplacage de chaines
/////////////////////////////////////////////////////////////////////////



	//Remplace toutes les occurences de la chaine a par la chaine b dans le fichier courant  
	bool remplaceChaine(char * a,char * b);					
	
	//Remplace toutes les occurences de la chaine a par la chaine b dans le fichier courant à partir de la
	//position indiquée
	bool remplaceChaineAPartirDe(char * a,char * b,int pos);			
	
	//Remplace toutes les occurences de la chaine a par la chaine b dans le fichier courant jusqu'à la
	//position indiquée
	bool remplaceChaineJusqua(char * a,char * b,int pos);				
	
	//Remplace toutes les occurences de la chaine a par la chaine b dans le fichier situées entre pos1 et pos2
	//la methode remplacera les mots qui débordent sur la droite mais pas sur la gauche
	bool remplaceChainePartie(char * a,char * b,int pos1,int pos2);	




/////////////////////////////////////////////////////////////////////////
//	Fonctions d'effacage
/////////////////////////////////////////////////////////////////////////


	//Efface le fichier courant
	bool effacer();							 		
	
	//Efface le fichier spécifié (les données car le fichier existe toujours)
	bool effacer(char * nom_fichier);        		
	
	//Efface la partie du fichier spécifiée (de pos sur longueur)
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	bool effacePartie(int pos,int longueur); 		
	
	//Efface le fichier à partir de la position spécifiée
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	bool effaceAPartirDe(int pos);								
	
	//Efface le fichier jusqu'à la position spécifiée
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	bool effaceJusqua(int pos);									
	
	//Efface toutes les occurences de la chaine spécifiée (remplace par rien en fait)
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	bool effaceChaine(char * chaine);		 			


/////////////////////////////////////////////////////////////////////////
//	Fonctions de copie
/////////////////////////////////////////////////////////////////////////


	////Copie le contenu de a dans b (crée b si besoin ou écrase les données de b)
    bool copie(char * source,char * dest); //copie le contenu de a dans b (crée b si besoin ou écrase les données de b)     
	
	//Copie le contenu de f vers le fichier dest
	bool copieVers (char * dest);  											
	
	//Copie le contenu de source dans le fichier f (écrase les données ds f si besoin)
	bool copieDe (char * source);  
	
	//Copie la partie de a spécifiée dans b
	bool copiePartie(char * source,char * dest, int pos, int longueur); //copie la partie de a spécifiée dans b			
	
	//Copie le contenu de a (à partir de pos) dans b
	bool copieAPartirDe (char * source,char * dest, int pos);          


/////////////////////////////////////////////////////////////////////////
//	Insertion
/////////////////////////////////////////////////////////////////////////


	//Insert le contenu d'une chaine à l'endroit spécifié
	bool insertChaine(char * chaine,int pos);																				

	//insert le contenu d'un autre fichier à l'endroit spécifié	
	bool insertFichier(char * fichier,int pos); 	




/////////////////////////////////////////////////////////////////////////
//	Fonctions de concaténation
/////////////////////////////////////////////////////////////////////////

	//Concatene source a la suite de dest (source reste inchangé)
	bool concatFichier(char * source,char * dest); 		
	
	//Concatene source a la suite de f (source reste inchangé)
	bool concatFichierDe(char * source); 						
	
	//Concatene f a la suite de dest (f reste inchangé)
	bool concatFichierVers(char * dest); 

	//Concatene chaine a la suite du fichier courant
	bool concatChaine(char * chaine);																																			
	
	//Concatene chaine à la suite du fichier spécifié
	bool concatChaineFichier(char * chaine,char * fichier,int longueur);





/////////////////////////////////////////////////////////////////////////
//	Fonctions de dénombrement
/////////////////////////////////////////////////////////////////////////
	
	//Renvoie le nombre d'ocurences de 'chaine'
	int nbOccurences(char * chaine);
	
	//Renvoie le nombre de lignes IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	int getNbLignes() {return nbLignes;};
	
	//Renvoie le nombre de mots IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	int getNbMots(){ return nbMots;};
	


/////////////////////////////////////////////////////////////////////////
//	Fonctions pour trouver des positions particulières
/////////////////////////////////////////////////////////////////////////

	//Renvoie la position du début du mot spécifié par son numéro (a) 
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	int getPosDebutMot(int a) { 
		if (a>=0 && a<=nbMots) return indexFinMots.at(a-1); //Le premier mot est le mot n°1 (Convention KissyFroth)
		else return -1;
	};  
	
	//Renvoie la position de la fin du mot spécifié par son numéro (a) 
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	int getPosFinMot(int a)
	{ 
		if (a>=0 && a<=nbMots) return indexFinMots.at(a-1);
		else return -1;
	};
	
	//Renvoie la position du début de la ligne spécifiée par son numéro (a) 
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	int getPosLigne(int a) 
	{ 
		if (a>=0 && a<=nbLignes) return indexLignes.at(a-1);
		else return -1;
	};
	
	//Renvoie le numéro du mot spécifié par une position (du moment que la position est dans le mot c'est bon)
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	int getNumMot(int pos);
	
	//Renvoie le numéro de la ligne spécifiée par une position (du moment que la position est dans la ligne c'est bon)
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	int getNumLigne(int pos);



/////////////////////////////////////////////////////////////////////////
//	Fonctions diverses
/////////////////////////////////////////////////////////////////////////

	//Compare si 2 chaines sont identiques sur la longueur spécifiée (en partant du début) 
	bool egalChaines(char * a,char * b,int longueur);				
	
	//Renvoie vrai si le caractere a appartient a la chaine b faux sinon
	bool appartient(char a,char * b);

	
	
	//Fonction Mise A Jour Index
	//Certainement la fonction la plus importante de la classe
	//Elle sert à remplir les tableaux d'indexations de tous les mots 'indexMots' et de toutes les lignes 'indexLignes'
	//mis en attributs private
	//Elle sert aussi à dénombrer le nombre de mots et de lignes
	//Vous devrez l'appeller avant chaque fonction de statistiques ou de positionnement (fonctions classées dans
	// "denombrement" ou "positions particulieres") à moins qu'aucun changement n'ait été effectué depuis le dernier appel
	//La chaine "separateurs" désigne tous les caractéres que vous souhaitez voir comme étant des séparateurs de mots
	//Par exemple " " ou "*" peuvent etre désignés comme separateurs et ne feront donc jamais parti de mots 
	//Le caractere de saut de ligne '\n' et les guillemets '"' sont considérés comme des séparateurs par défaut
	bool MAJIndex(char * separateurs);
	

	//Met a jour uniquement l'index des lignes
	bool MAJIndexLignes();


	
	
	//Retourne true si le mot n° nb répond aux criteres de la chaine
	//Le caractere * peut désigner n'importe quelle chaine de caracteres
	//EXEMPLE : le mot "banane"
	// motCriteres renverra "true" aux criteres "*a*a*" (il y a bien 2 "a" qui ne sont pas forcés de se suivre) 
	// motCriteres renverra "true" aux criteres "ba*" (banane commence par ba + autre chose après)
	// motCriteres renverra "false" aux criteres "*aa*" (les 2 "a" devraient se suivre pour que ce soit vrai)
	// motCriteres renverra "true" aux criteres "*b*" (le caractere "*" peut ne rien désigner : il ny a rien avant b)
	// motCriteres renverra "false" aux criteres "*u*" (le caractere "u" n'est pas présent dans "banane")
	// motCriteres renverra "false" aux criteres "*n" (banane ne se termine pas par n")
	//
	// min et max sont des filtres de taille du mot recherché
	// si vous voulez des mots de toutes les tailles vous devrez mettre en param 0 pour min et -1 pour max
	//
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	//
	bool motCriteres(char * crit,int nb,int min,int max);

	
	
	//Copie tous les mots du fichier courant qui répondent aux critères "crit" dans le fichier f;
	// min et max sont des filtres de taille du mot recherché
	// si vous voulez des mots de toutes les tailles vous devrez mettre en param 0 pour min et -1 pour max
	int copieMots(char * fichier,char * crit,int min,int max);





};