Tfe

Old stuff/ecole_etude_fac_de_pau/licence_3/projet_lzw/include/deflater.cpp

/*
    This file is part of projet_lzw_univ_pau.

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

    projet_lzw_univ_pau is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with projet_lzw_univ_pau; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/



#include "deflater.h"
#include <iostream>




/* Constructeur */
Deflater::Deflater()
{
    valeur_max=1; // Pour commencer l indice a 1
    std::vector<char> mot; // Chaque mot est represente comme un vecteur de chat
    for (int i=0;i<256;i++)
    {
        mot.clear(); 
	mot.push_back(i); 
	add_word(mot); // creation du dictionnaire de base (ascii de 0 a 255)
    }
}



/* Fonction d'entree */
void Deflater::setInput(std::vector<char>& msg)
{
    /* On capture la taille du vecteur pour ne pas devoir la recalculer a chaque boucle */
    int size=msg.size();
    for(int i=0;i<size;i++)
    {
    buffer.push_back(msg[i]);
    }
}


int Deflater::needInput()
{
// Fonction de l'ennonce ?
}
    


/* Ajout d'un mot dans le dictionnaire: fonction privee */
void Deflater::add_word(const std::vector<char>& mot)
{
    dico[mot]=valeur_max;
    valeur_max++;    
}


/* Recherche d un mot du dictionnaire: fonction privee */
int Deflater::find_word(const std::vector<char>& recherche)
{
     if (dico.find(recherche) == dico.end()) { return 0; } else { return 1; }
     
}



/* Methode de compression */
int Deflater::deflate(int methode)
{
    /* On vide le buffer de sortie (compression) */
    compression.clear();

    /* Variables temporaires */
    int reste=0;
    int debut=0;
    int longueur;
    std::vector<char> mot;
    std::vector<char> ancien_mot;
    int size=buffer.size();
    
    /* Nous avons ici une boucle sur 2 conditions:
	* S il reste des elements a etudier 
	* S il reste 1 element mais que le buffer courant n est pas 
	  final( Appel de la fonction avec un buffer intermediaire) 	
    */
    while(!buffer.empty() && reste!=1) 
    {
	size=buffer.size();
	longueur=1;
	
	mot.clear();
	/* On capture toujours la premiere lettre du buffer */
	mot.push_back(buffer[0]);
	ancien_mot=mot;

	/* Tant que le mot courant est trouve ... */
	while (find_word(mot) && longueur<=size )
	{
	    ancien_mot=mot;
	    longueur++;
	    /* On prends un mot de longueur plus grande */
	    mot.push_back(buffer[longueur-1]); 
	}

	/* Si la mode intermediaire est appelee, il faut verifier que le mot
	   le plus grand trouve n englobe pas tout les caracteres restants. 
	*/
	if (longueur>=(size) && methode!=0) { 
	    reste=1; 
	}
	else
	{
	/* Ajout du mot */
        add_word(mot); 
	/* Ajout du mot de longueur -1 dans le buffer */
	compression.push_back(dico[ancien_mot]);

	debut=(longueur >1? longueur-1:longueur);
	/* On supprime les caracteres deja traites. */
	buffer.erase(buffer.begin(),buffer.begin()+debut);
	debut=0;
	}

    }
    
/* Calcul du taux de compression pour l element courant */    
compression_ratio = (float)compression.size() / size;    
return 1;
}