/*
 * Créé le 17 aoűt 2004
 *
 */
package traitement.section;

import information.DomaineIncompatibleException;
import information.InformationEvent;
import information.InformationIncompleteException;
import information.InformationListener;
import information.InterfaceInformation;
import information.domaine.DomaineComplexe;
import information.domaine.DomaineSimple;
import information.tpt.InterfaceContientTPT;
import information.tpt.TPT;
import information.tpt.VectorTPT;
import information.type.Type;
import information.type.VectorType;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Vector;

import principal.Commun;
import principal.copiercoller.CopiableIncompatibleException;
import principal.copiercoller.HomonymeIntrouvableException;
import principal.copiercoller.InterfaceCopiable;
import principal.copiercoller.InterfaceHomonyme;
import principal.copiercoller.Tampon;
import resultat.vue.VueTPT;
import resultat.vue.VueType;

import fichier.ContenuFichierIncompatibleException;
import fichier.TypeFichierIncompatibleException;
import fichier.VersionFichierIncompatibleException;
import fichier.flux.RageInputStream;
import fichier.flux.RageOutputStream;
import fonction.FonctionEvent;
import fonction.FonctionListener;
import fonction.InterfaceFonctionFils;
import fonction.tpt.InterfaceFonctionFilsTPT;
import fonction.tpt.InterfaceFonctionParentTPT;
import fonction.tpt.TPTApprentissage0;
import gui.InterfaceAffichable;
import traitement.TraitementEvent;
import traitement.TraitementIncompletException;
import traitement.TraitementListener;
import traitement.modele.Modele;
import traitement.noeud.fonctionnel.AbstractNoeudFonctionnelPlein;
import traitement.noeud.fonctionnel.NoeudFonctionnelEndogene;

/**
 * constituants des NoeudEndogenes.
 * Ce type de Section est utilisé pour gérer l'apprentissage dans un NoeudFonctionnelEndogene.
 * Une SectionApprentissage possčde un historique des TPT
 * sous la forme d'un VectorTPT.
 * Elle possčde également une fonction d'apprentissage.
 * 
 * @author	Vincent Labatut
 * @version	1
 * @see		traitement.noeud.fonctionnel.NoeudFonctionnelEndogene
 * @see		traitement.section.AbstractSectionInformationEndogene
  */

public class SectionApprentissage implements InterfaceSection, InterfaceFonctionParentTPT, InformationListener, FonctionListener, InterfaceContientTPT
{	/**
	 * Historique des TPTs.
	  */
	private VectorTPT vectorTPT;
	/**
	 * InterfaceNoeudFonctionnel parent de cette AbstractSectionInformation.
	  */
	private NoeudFonctionnelEndogene parent;
	/**
	 * Liste des TraitementListeners qui écoutent cette AbstractSectionInformation.
	  */
	private Vector vectorTraitementListener;
	/**
	 * Fonction d'apprentissage.
	  */
	private InterfaceFonctionFilsTPT fonctionTPT;
	/**
	 * Nombre de fonction TPT
	  */
	public static int MAX_TPT = 1;
	/**
	 * Index de la fonction TPT
	  */
	public static int INDEX_TPT = 0;
	/**
	 * Répertoire contenant les résultats de la simulation.
	  */
	private File repertoireSimulation;
	/**
	 * la Vue associée aux TPT de cette Section.
	  */
	private VueTPT vueTPT;
	/**
	 * la liste des Vuee associées aux Archétypes de cette Section.
	  */
	private VueType[] tabVueArchetype;
	/**
	 * indique si cet objet a été modifé depuis sa derničre sauvegarde.
	  */
	private boolean modifie;

//	----------------------------------------	
//	Constructeurs
//	----------------------------------------
	/**
	 * Constructeur pour créer une SectionApprentissage de parent le NoeudFonctionnelEndogene
	 * passé en paramčtre.
	 * 
	 * @param	p	parent de cette SectionInformationEndogene
	 * 
	  */
	public SectionApprentissage(NoeudFonctionnelEndogene p)
	{	
    	//
		vectorTraitementListener = new Vector();
		//
		parent = p;
		// historique
		vectorTPT = new VectorTPT();
		TPT tpt = new TPT(this);
		tpt.addInformationListener(this);
		vectorTPT.addTPT(tpt);
		// fonction d'apprentissage
		fonctionTPT = new TPTApprentissage0(this);
		fonctionTPT.addFonctionListener(this);
		fonctionTPT.setParent(this);
		setModifie();
	}

//	----------------------------------------	
//	HistoriqueTPT
//	----------------------------------------
	/*
	 * 
	 */
	public TPT getTPT(int instant)
	{	if (instant<0)
			return vectorTPT.getTPT(0);
		else
			return vectorTPT.getTPT(instant);
	}
	/**
	 * renvoie la TPT initiale.
	 * 
	 * @return	la TPT initiale.
	  */
	public TPT getTPTInitiale()
	{	return getTPT(0);
	}
	/**
	 * rajoute une TPT dans l'historique.
 	 * Emission de TraitementEvents de raffraichissement et de complétude.
	 * 
	 * @param 	tpt	la TPT ŕ rajouter.
	 * @throws	DomaineIncompatibleException si les Domaine de la TPT sont
	 * 			incompatibles avec ceux de cette SectionApprentissage.
	  */
	public void addTPT(TPT tpt) throws DomaineIncompatibleException
	{	// on teste les domaines
		if (getDomaineEmission().estCompatibleDomaine(tpt.getDomaineEmission()) && 
			getDomaineActivation().estCompatibleDomaine(tpt.getDomaineActivation()))
		{	vectorTPT.addTPT(tpt);
			tpt.setParent(this);
		}
		else
			throw new DomaineIncompatibleException(getIdentification()+":"+tpt.getIdentification());
		setModifie();
	    fireTraitementRaffr(new TraitementEvent(this));
	}	
	/**
	 * remplace, dans l'historique, la TPT 
	 * de l'instant spécifié, par la TPT passée en paramčtre.
	 * Si aucune TPT n'existe ŕ l'instant spécifié, la TPT est simplement rajoutée.
 	 * Emission de TraitementEvents de raffraichissement et de complétude.
	 * 
	 * @param 	instant	de la substitution.
	 * @param 	tpt	la TPT ŕ substituer.
	 * @throws	DomaineIncompatibleException si les Domaine de la TPT sont
	 * 			incompatibles avec ceux de cette SectionApprentissage.
	  */
	public void setTPT(int instant, TPT tpt) throws DomaineIncompatibleException
	{	// on teste les domaines
		if (getDomaineEmission().estCompatibleDomaine(tpt.getDomaineEmission()) && 
			getDomaineActivation().estCompatibleDomaine(tpt.getDomaineActivation()))
			if (vectorTPT.size()>instant)
			{	getTPT(instant).remove();
				vectorTPT.setTPT(instant,tpt);
				tpt.setParent(this);
			}
			else
				addTPT(tpt); 
		else
			throw new DomaineIncompatibleException(getIdentification()+":"+tpt.getIdentification());
		setModifie();
	    fireTraitementRaffr(new TraitementEvent(this));
	}	
	/**
	 * remplace la TPT initiale 
	 * par la TPT passée en paramčtre.
	 * 
	 * @param 	tpt	la TPT ŕ substituer.
	 * @throws	DomaineIncompatibleException si les Domaine de la TPT sont
	 * 			incompatibles avec ceux de cette SectionApprentissage.
	  */
	public void setTPTInitiale(TPT tpt) throws DomaineIncompatibleException
	{	getTPTInitiale().removeInformationListener(this);
		setTPT(0,tpt);
		tpt.addInformationListener(this);
	}	
	
//	----------------------------------------	
//	Domaine
//	----------------------------------------
	/*
	 * 
	 */
	public DomaineComplexe getDomaineActivation()
	{	DomaineComplexe resultat = null;
		resultat = parent.getDomaineActivation();
		return resultat;
	}
	/*
	 * 
	 */
	public DomaineSimple getDomaineEmission()
	{	DomaineSimple resultat = null;
		resultat = parent.getDomaineEmission();
		return resultat;
	}

//	----------------------------------------	
//	Parent
//	----------------------------------------
	/**
	 * renvoie le NoeudFonctionnelEndogene parent de cette SectionApprentissage.
	 * 
	 * @return 	le NoeudFonctionnelEndogene parent.
	  */
	public AbstractNoeudFonctionnelPlein getParent()
	{	return parent;
	}
	/**
	 * modifie l'InterfaceNoeudFonctionnel parent de cette SectionApprentissage.
	 * Ceci peut provenir d'un changement de Modele, donc cette action est
	 * propagée aux fils de cette SectionApprentissage.
	 * 
	 * @param	n	le nouveau NoeudFonctionnelEndogene parent de cette SectionApprentissage.
	  */
	public void setParent(NoeudFonctionnelEndogene n)
	{	parent = n;
		for (int i=0;i<vectorTPT.size();i++)
			vectorTPT.getTPT(i).setParent(this);
		fonctionTPT.setParent(this);		
	}

//	----------------------------------------	
//	Tampon
//	----------------------------------------
	/**
	 * renvoie le Tampon du Projet auquel appartient indirectement cette SectionApprentissage.
	 * 
	 * @return 	le Tampon du Projet.
	  */
	public Tampon getTampon()
	{	Tampon resultat = null;
		resultat = parent.getTampon();
		return resultat;
	}
	
//	----------------------------------------	
//	  Fichier
//	----------------------------------------
	/**
	 * renvoie le répertoire qui contiendra
	 * les résultats de la simulation.
	 * 
	 * @return	le répertoire contenant les résultats de la simulation.
	  */
	public File getRepertoireSimulation()
	{	return repertoireSimulation;
	}
	/**
	 * modifie le répertoire de simulation.
	 * 
	 * @param	repertoire	nouveau répertoire de simulation.
	  */
	public void setRepertoireSimulation(File repertoire)
	{	repertoireSimulation = repertoire;
	}
	
//	----------------------------------------	
//	Modele
//	----------------------------------------
	/*
	 * 
	 */
	public Modele getModele()
	{	Modele resultat = null;
		resultat = parent.getModele();
		return resultat;
	}

//	----------------------------------------	
//	This
//	----------------------------------------
	/*
	 * 
	 */
	public void remove()
	{	fireTraitementSuppr(new TraitementEvent(this));
		//
		getTPTInitiale().removeInformationListener(this);
		while (vectorTPT.size() != 0)
		{	vectorTPT.getTPT(0).remove();
			vectorTPT.removeTPT(0);
		}
		vectorTPT = null;
		// fonctionTPT
		fonctionTPT.removeFonctionListener(this);
		fonctionTPT.remove();
		fonctionTPT = null;
		// 
		parent = null;
		//
		if (vueTPT != null)
			vueTPT.remove();
		if (tabVueArchetype != null)
			for (int i=0;i<tabVueArchetype.length;i++)
				tabVueArchetype[i].remove();
		//
	}

//	----------------------------------------	
//	  InterfaceParent
//	----------------------------------------
	/*
	 * renvoie le fils numéro 'rang' sans tenir compte du type de fils.
	 * 
	  */
	public InterfaceFonctionFils getFils(int rang)
	{	return fonctionTPT;
	}
	/*
	 * ajoute un fils sans tenir compte du type de fils.
	 * Inutile ici, on ne peut rien rajouter, seulement remplacer.
	 * 
	  */
	public void addFils(InterfaceFonctionFils fils)
	{	//		
	}
	/*
	 * remplace un fils sélectionné en fonction de sa place,
	 * par un nouveau fils passé en paramčtre
	 * sans tenir compte du type de fils.
	 * 
	  */
	public void setFils(int rang, InterfaceFonctionFils fils)
	{	setFonctionTPT((InterfaceFonctionFilsTPT)fils);
	}
	/*
	 * crée et ajoute un nouveau fils sans tenir compte du type de fils.
	 * Inutile ici, on ne peut rien rajouter, seulement remplacer.
	  */
	public void newFils(Class classe)
	{	//	
	}
	/*
	 * 
	  */
	public void remplacerFils(InterfaceFonctionFils ancien, InterfaceFonctionFils nouveau)
	{	setFonctionTPT((InterfaceFonctionFilsTPT)nouveau);
	}
	/*
	 * 
	  */
	public void removeFils(InterfaceFonctionFils fils)
	{	setFonctionTPT(new TPTApprentissage0(this));
	}
	/*
	 * 
	  */
	public void removeFils(int rang)
	{	setFonctionTPT(new TPTApprentissage0(this));
	}
	/*
	 * 
	  */
	public int sizeFils()
	{	return MAX_TPT;
	}
	/*
	 * 
	  */
	public int indexOfFils(InterfaceFonctionFils fils)
	{	if (fils == fonctionTPT)
			return INDEX_TPT;
		else
			return -1;
	}
	/*
	 * 
	  */
	public void traiterEltModif(int cat, int type, int index)
	{	//inutile ici
	}

//	----------------------------------------	
//	InterfaceTraitement
//	----------------------------------------
	/*
	 * 
	 */
	public void addTraitementListener(TraitementListener i)
	{	vectorTraitementListener.add(i);
	}
	/*
	 * 
	 */
	public void removeTraitementListener(TraitementListener i)
	{	vectorTraitementListener.remove(i);
	}
	/**
	 * annonce la suppression de cette AbstractSectionInformation.
	 * Chaque TraitementListener doit se supprimer lui-męme de la liste des listeners de cette AbstractSectionInformation.  
	 * 
	 * @param 	e	le TraitementEvent qui est émis vers les TraitementListeners. 
	  */
	private void fireTraitementSuppr(TraitementEvent e)
	{	
	    while (vectorTraitementListener.size()!=0)
			try
			{	((TraitementListener) vectorTraitementListener.get(0)).traitementSuppr(e);
			}
			catch (TraitementIncompletException e1)
			{	e1.printStackTrace();
			}
	}
	/**
	 * annonce un raffraichissement de cette AbstractSectionInformation.
	 * 
	 * @param 	e	le TraitementEvent qui est émis vers les TraitementListeners. 
	  */
	private void fireTraitementRaffr(TraitementEvent e)
	{	
	    for (int i=0;i<vectorTraitementListener.size();i++)
			try
			{	((TraitementListener) vectorTraitementListener.get(i)).traitementRaffr(e);
			}
			catch (TraitementIncompletException e1)
			{	e1.printStackTrace();
			}
	}
	/**
	 * annonce un échange.
	 * 
	 * @param 	e	l'TraitementEvent qui est émis vers les TraitementListeners. 
	  */
	private void fireTraitementRempl(TraitementEvent e)
	{	for (int i=0;i<vectorTraitementListener.size();i++)
			try
			{	((TraitementListener) vectorTraitementListener.get(i)).traitementRempl(e);
			}
			catch (TraitementIncompletException e1)
			{	e1.printStackTrace();
			}
	}
	/**
	 * annonce un masquage.
	 * 
	 * @param 	e	l'TraitementEvent qui est émis vers les TraitementListeners. 
	  */
	private void fireTraitementCache(TraitementEvent e)
	{	for (int i=0;i<vectorTraitementListener.size();i++)
			try
			{	((TraitementListener) vectorTraitementListener.get(i)).traitementCache(e);
			}
			catch (TraitementIncompletException e1)
			{	e1.printStackTrace();
			}
	}
		
//	----------------------------------------	
//	InformationListener
//	----------------------------------------
	/*
	 * appelée lors de la réception d'un InformationEvent de suppression.
	 * Cette SectionApprentissage écoute sa TPT initiale.
	 * C'est elle qui décide de leur suppression, donc cette méthode est inutile ici.
	  */
	public void informationSuppr(InformationEvent e)
	{	
	}
	/*
	 * appelée lors de la réception d'un InformationEvent de modification de constituant.
	 * Cette SectionApprentissage écoute sa TPT initiale.
	  */
	public void informationEltModif(InformationEvent e)
	{	setModifie();
		fireTraitementRaffr(new TraitementEvent(this));
	}
	/*
	 * appelée lors de la réception d'un InformationEvent de raffraichissement.
	 * Cette SectionApprentissage écoute sa TPT initiale.
	 * On lčve un TraitementEvent de raffraichissement
	  */
	public void informationRaffr(InformationEvent e)
	{	if (e.getSource().estModifie())
		{    setModifie();
			fireTraitementRaffr(new TraitementEvent(this));
		}
	}
	/*
	* appelée quand l'InterfaceInformation a été remplacée.
	* Cette méthode est destinée ŕ la GUI.
	 */
	public void informationRempl(InformationEvent e)
	{
	}
	/*
	* appelée quand le nom de l'InterfaceInformation a été modifié.
	* Cette méthode est destinée ŕ la GUI.
	 */
	public void informationCache(InformationEvent e)
	{
	}
	
	public void informationChangementModele(InformationEvent e)
	{	InterfaceInformation temp = (InterfaceInformation)e.getSource();
		try
		{	if (temp.getModele() != getModele())
			{	temp.removeInformationListener(this);
				if (temp instanceof TPT)
				{	vectorTPT.setTPT(0,new TPT(this)); 
					getTPTInitiale().addInformationListener(this);
				} 
			} 
		}
		catch (InformationIncompleteException e1)
		{	e1.printStackTrace();
		}	
	}		
		
//	----------------------------------------	
//	FonctionListener
//	----------------------------------------
	/*
	 * appelée lors de la réception d'un FonctionEvent de suppression.
	 * Cette SectionApprentissage écoute sa fonction d'apprentissage.
	 * C'est elle qui décide de leur suppression, donc cette méthode est inutile ici.
	  */
	public void fonctionSuppr(FonctionEvent e)
	{	
	}
	/*
	 * appelée lors de la réception d'un FonctionEvent de modification de constituant.
	 * Cette SectionApprentissage écoute sa fonction d'apprentissage.
	 * On fait suivre un TraitementEvent de raffraichissement.
	  */
	public void fonctionEltModif(FonctionEvent e)
	{	setModifie();
		fireTraitementRaffr(new TraitementEvent(this));
	}
	/*
	 * appelée lors de la réception d'un FonctionEvent de raffraichissement.
	 * Cette SectionApprentissage écoute sa fonction d'apprentissage.
	 * On fait suivre un TraitementEvent de raffraichissement
	  */
	public void fonctionRaffr(FonctionEvent e)
	{	if (e.getSource().estModifie())
		{    setModifie();
			fireTraitementRaffr(new TraitementEvent(this));
		}
	}
	/*
	 * appelée lors de la réception d'un FonctionEvent de remplacement.
	 * méthode réservée ŕ la GUI, inutile ici.
	  */
	public void fonctionRempl(FonctionEvent e)
	{	
	}
	/*
	 * appelée lors de la réception d'un FonctionEvent de masquage.
	 * Utile seulement pour la GUI.
	  */
	public void fonctionCache(FonctionEvent e)
	{	
	}
	/*
	 * appelée lors de la réception d'un FonctionEvent de changement de Modele.
	 * Cette SectionInformationEndogene écoute ses deux fonctions.
	 * La fonction concernée est remplacée ici par une fonction neutre.
	  */
	public void fonctionChangementModele(FonctionEvent e)
	{	InterfaceFonctionFils temp = (InterfaceFonctionFils)e.getSource();
		if (temp.getModele() != getModele())
		{	temp.removeFonctionListener(this);
			if (temp instanceof InterfaceFonctionFilsTPT)
			{	fonctionTPT = new TPTApprentissage0(this);
				fonctionTPT.addFonctionListener(this);
			}
		} 
	}
				
//	----------------------------------------	
//	InterfaceContientTPT
//	----------------------------------------
	/*
	 * 
	 */
	public int indexOfTPT(TPT tpt)
	{	return vectorTPT.indexOfObjet(tpt);
	}

//	----------------------------------------	
//	Simulation
//	----------------------------------------
	/*
	 * détermine si cette SectionApprentissage est complčtement définie.
	 * Cette méthode est appellée juste avant la simulation.
	 * Une SectionApprentissage est complete si son historique contient au moins
	 * un élément chacun, et que ces éléments sont complets,
	 * et enfin si sa fonction d'apprentissage est complčte. 
	  */
	public boolean estComplet()
	{	boolean resultat;
		
		resultat = true;
		if (!fonctionTPT.estComplet())
			resultat = false;
		else if (vectorTPT.size()==0)
			resultat = false;
		else if (!vectorTPT.estComplet())
			resultat = false;
		return(resultat);
	}
	/**
	 * prépare la Section ŕ la simulation. 
	 * 
	  */
	public void preparerSimulation()
	{	// on prépare le répertoire de simulation
		setRepertoireSimulation(new File
			(	getParent().getRepertoireSimulation().getPath()
				+File.separator
				+Commun.STRING_APPRENTISSAGE
			));
		getTPTInitiale().normaliser();
	}
	/**
	 * interrompt la simulation, c'est ŕ dire que les Noeuds doivent
	 * ętre réinitialisés et les fichiers ouverts doivent ętre fermés.
	 * 
	 * @throws	 IOException	si une erreur survient lors de l'accčs au fichier.
	 * @throws	 ContenuFichierIncompatibleException	si le contenu du fichier est erroné.
	 * @throws	 VersionFichierIncompatibleException	si la version de Rage qui a généré le fichier n'est pas compatible avec cette version-ci.
	 * @throws	 TypeFichierIncompatibleException	le fichier n'est pas un fichier de resultats.
	  */
	public void interrompreSimulation()
	{	
		// on supprime toutes les valeurs sauf l'initiale
		while (vectorTPT.size()>1)
		{	vectorTPT.getTPT(1).remove();
			vectorTPT.removeTPT(1);
		}
	}
	/**
	 * finalise la simulation dans cette Section. 
	 * 
	 * @throws	 IOException	si une erreur survient lors de l'accčs au fichier.
	 * @throws	 ContenuFichierIncompatibleException	si le contenu du fichier est erroné.
	 * @throws	 VersionFichierIncompatibleException	si la version de Rage qui a généré le fichier n'est pas compatible avec cette version-ci.
	 * @throws	 TypeFichierIncompatibleException	le fichier n'est pas un fichier de resultats.
	  */
	public void terminerSimulation() throws IOException
	{	// on enregistre les résultats
		File fichier = new File
			(	getRepertoireSimulation().getPath()
				+"-"+Commun.STRING_TPT
				+Commun.EXT_RESULTAT);
		FileOutputStream out = null;
		try
		{	out = new FileOutputStream(fichier);
			RageOutputStream outputStream = new RageOutputStream(out);
			// on écrit la version du fichier
			outputStream.writeObject(Commun.VERSION);
			// on écrit le type de fichier
			outputStream.writeObject(Commun.FICHIER_CODE_RESULTAT);
			// le Domaine d'activation
			outputStream.writeDomaine(getDomaineActivation());
			// puis le Domaine d'émission
			outputStream.writeDomaine(getDomaineEmission());
			// la taille du Vector ŕ écrire
			outputStream.writeObject(new Integer(vectorTPT.size()));
			// et enfin chaque information			
			for (int i=0;i<vectorTPT.size();i++)
				outputStream.writeTPT(vectorTPT.getTPT(i));
			out.close();
		}
		catch (FileNotFoundException e)
		{	if (out != null)
				out.close();
			effacerHistorique();
			throw e;
		}
		catch (IOException e)
		{	if (out != null)
				out.close();
			effacerHistorique();
			throw e;
		}
		//
		effacerHistorique();
	}
	/**
	 * supprime toutes les valeurs des historiques, sauf les valeurs initiales.
	 * Cette méthode est utilisée pour interrompre/finaliser une simulation.
	 * 
	  */
	public void effacerHistorique()
	{	// on supprime toutes les valeurs sauf l'initiale
		while (vectorTPT.size()>1)
		{	vectorTPT.getTPT(1).remove();
			vectorTPT.removeTPT(1);
		}
	}
	/**
	 * ouvre le fichier de données précédemment enregistré par cette Section suite
	 * ŕ une simulation, et met les données dans l'historique.
	 * 
	 * @throws	VersionFichierIncompatibleException	si le fichier n'a pas été généré par une version de Rage compatible avec cette version-ci.
	 * @throws	TypeFichierIncompatibleException	si le fichier qu'on tente d'ouvrir n'est pas un fichier de résultats.
	 * @throws	ContenuFichierIncompatibleException	si le contenu du fichier est erroné.
	 * @throws	IOException	si une erreur survient lors de l'accčs au fichier.
	 * @throws	ClassNotFoundException	si une erreur survient lors de l'accčs au fichier.
	 * @throws	InformationIncompleteException	si le fichier contient des informations incomplčtes.
	 * @throws	TraitementIncompletException	si le fichier contient des traitements incomplets.
	   */
	public void recupererResultat() throws ContenuFichierIncompatibleException, VersionFichierIncompatibleException, TypeFichierIncompatibleException, IOException, ClassNotFoundException, InformationIncompleteException, TraitementIncompletException
	{	setRepertoireSimulation(new File
		(	getParent().getRepertoireSimulation().getPath()
			+File.separator
			+Commun.STRING_APPRENTISSAGE
		));		
	
		// on ouvre les résultats de Type
		File fichier = new File
			(	getRepertoireSimulation().getPath()
				+"-"
				+Commun.STRING_TPT
				+Commun.EXT_RESULTAT);
		FileInputStream in = new FileInputStream(fichier);			
		RageInputStream inputStream = new RageInputStream(in, true, true);

		// on récupčre la version du fichier
		Float version = (Float)inputStream.readObject();
		if (version.compareTo(Commun.VERSION)>0)
			throw new VersionFichierIncompatibleException(fichier.getPath());

		// on récupčre le type de fichier
		String typeFichier = (String)inputStream.readObject();
		if (!typeFichier.equals(Commun.FICHIER_CODE_RESULTAT))
			throw new TypeFichierIncompatibleException(fichier.getPath());

		// le Domaine d'activation
		{	DomaineComplexe dom;
			// NOTE utilisation abusive du parent comme pčre du domaine
			dom = inputStream.readDomaineComplexe(((NoeudFonctionnelEndogene)getParent()).getSectionActivation());
			if (!dom.egaleDomaine(getDomaineActivation()))
				throw new ContenuFichierIncompatibleException(fichier.getPath());
			// on n'a plus besoin de ce Domaine, il ne sert que pour le test.
			dom.remove();
		}
		{	DomaineSimple dom;
			// NOTE utilisation abusive du parent comme pčre du domaine
			dom = inputStream.readDomaineSimple(((NoeudFonctionnelEndogene)getParent()).getSectionEmission());
			if (!dom.egaleDomaine(getDomaineEmission()))
				throw new ContenuFichierIncompatibleException(fichier.getPath());
			// on n'a plus besoin de ce Domaine, il ne sert que pour le test.
			dom.remove();
		}

		// la taille du Vector ŕ lire
		int taille = ((Integer)inputStream.readObject()).intValue();

		// et enfin chaque information			
		for (int i=1;i<taille;i++)
			try
			{	TPT tempTPT = inputStream.readTPT(this);
				if (!tempTPT.getDomaineActivation().egaleDomaine(getDomaineActivation())
					|| !tempTPT.getDomaineEmission().egaleDomaine(getDomaineEmission()))
					throw new ContenuFichierIncompatibleException(fichier.getPath());
//					if (!tempType.estComplet())
//						throw new ContenuFichierIncompatibleException();
				addTPT(tempTPT);
			}
			catch (InformationIncompleteException e)
			{	e.printStackTrace();				
				throw new ContenuFichierIncompatibleException(fichier.getPath());
			}
			catch (DomaineIncompatibleException e)
			{	throw new ContenuFichierIncompatibleException(fichier.getPath());
			}

		// on referme le fichier
		in.close();
	}

//	----------------------------------------	
//	  Copier/Coller
//	----------------------------------------
	/**
	 * renvoie une copie de cette SectionApprentissage.
	 * La nouvelle SectionApprentissage a le męme parent que cette SectionApprentissage, 
	 * mais c'est temporaire : la copie est destinée ŕ 
	 * ętre insérée dans un autre NoeudFonctionnelEndogene.
	 * L'historique, et la fonction qui composent 
	 * la copie sont des copies de celles de cette SectionApprentissage.
	 * 
	 * @return 	une copie de cette SectionApprentissage.
	  */
	public SectionApprentissage cloner()
	{	SectionApprentissage resultat;
		
		// COPIE
		resultat = new SectionApprentissage(parent);
		try
		{	// Fils
			resultat.setFonctionTPT((InterfaceFonctionFilsTPT)fonctionTPT.cloner());
			// Historiques
			resultat.setTPTInitiale(getTPTInitiale().cloner());
/*
			for (int i=0;i<vectorTPT.size();i++)
				resultat.addTPT(vectorTPT.getTPT(i).cloner());
*/				
		}
		catch (DomaineIncompatibleException e)
		{	e.printStackTrace();
		}
		resultat.setNonModifie();
		return resultat;
	}
	/*
	 * 
	 */
	public InterfaceHomonyme getHomonyme(Modele modele) throws HomonymeIntrouvableException
	{	InterfaceHomonyme resultat;
		if (modele == getModele())
		    resultat = this;
		else
		{	resultat = ((NoeudFonctionnelEndogene)parent.getHomonyme(modele)).getSectionApprentissage();
		}
		return resultat;
	}
	/*
	 * 
	 */
	public void copier()
	{	getTampon().set(this);
	}
	/*
	 *
	 */
	public boolean estCollable()
	{	boolean resultat = true;
	    Tampon tampon = getModele().getTampon();
		if (tampon.estVide())
			resultat = false;
		else
		{	InterfaceCopiable buffer = tampon.get();
			if (buffer instanceof TPT)
			{	if (getDomaineEmission().estCompatibleDomaine(((TPT)buffer).getDomaineEmission())
				        && getDomaineActivation().estCompatibleDomaine(((TPT)buffer).getDomaineActivation()))
			    	resultat = true;
				else
				    resultat = false;
			}
			else
				resultat = false;
		}
		return resultat;
	}
	/*
	 * colle dans cette SectionApprentissage une TPT contenue dans le Tampon, 
	 * qui vient remplacer la TPT initale.
	 * Il est également possible de coller la fonction d'apprentissage.
	 * Une ObjetRageIncompatibleException est levée si l'objet n'est 
	 * pas une TPT, ou plus généralement s'il est incompatible.
	  */
	public void coller() throws CopiableIncompatibleException
	{	Tampon tampon = getModele().getTampon();
		if (tampon.estVide())
			throw new CopiableIncompatibleException(getIdentification());
		InterfaceCopiable buffer = tampon.get();
		if (buffer instanceof TPT)
		{	TPT temp = (TPT) buffer;
			try
			{	setTPTInitiale(temp);
			}
			catch (DomaineIncompatibleException e)
			{	throw new CopiableIncompatibleException(getIdentification());
			}					
		}
		else
			throw new CopiableIncompatibleException(getIdentification());
	}
	
//	----------------------------------------	
//	InterfaceAffichable
//	----------------------------------------
	/*
	 * 
	 */
	public void remplacer(InterfaceAffichable a)
	{	SectionApprentissage sif = (SectionApprentissage) a;
		getTPTInitiale().remplacer(sif.getTPTInitiale());
		fonctionTPT.remplacer(sif.getFonctionTPT());
		//
		fireTraitementRempl(new TraitementEvent(this,(SectionApprentissage)a));
	}
	/*
	 * 
	 */
	public void cacher()
	{	getTPTInitiale().cacher();
		fonctionTPT.cacher();
		fireTraitementCache(new TraitementEvent(this));
	}
	
//	----------------------------------------	
//	Fonction
//	----------------------------------------
	/**
	 * renvoie l'InterfaceFonctionTPT remplissant le rôle
	 * de fonction d'apprentissage.
	 * 
	 * @return 	la fonction d'apprentissage.
	  */
	public InterfaceFonctionFilsTPT getFonctionTPT()
	{	return fonctionTPT;
	}
	/**
	 * substitue une nouvelle InterfaceFonctionTPT, passée en
	 * paramčtre, ŕ de fonction d'apprentissage.
 	 * Emission de TraitementEvents de raffraichissement et de complétude.
	 * 
	 * @param 	fct	la nouvelle fonction de Magnitude.
	  */
	public void setFonctionTPT(InterfaceFonctionFilsTPT fct)
	{	fonctionTPT.removeFonctionListener(this);
		fonctionTPT.remplacer(fct);
		fonctionTPT.remove();
		fonctionTPT= fct;
		fonctionTPT.addFonctionListener(this);
		fonctionTPT.setParent(this);
		setModifie();
	    fireTraitementRaffr(new TraitementEvent(this));
	}

//	----------------------------------------	
//	Divers
//	----------------------------------------
	/*
	 * 
	 */
	public String toString()
	{	StringBuffer resultat;
		
		resultat = new StringBuffer();
		resultat.append("TPT initiale : "+getTPTInitiale());
		resultat.append("Fonction TPT : "+fonctionTPT);
		return(resultat.toString());
	}

//	----------------------------------------	
//	Noeud
//	----------------------------------------
	/*
	 * 
	 */
	public NoeudFonctionnelEndogene getNoeud()
	{	return parent;
	}
	/**
	 * renvoie le Vector contenant tous les noms d'achétypes apparaissant
	 * dans l'historique des TPT.
	 * 
	 * @return	le Vector des noms des Archétypes.
	 * 
	  */
	public Vector getListeArchetype()
	{	Vector resultat = new Vector();
		
		for (int i=0;i<vectorTPT.size();i++)
		{	TPT tpt = getTPT(i);
			for (int j=0;j<tpt.size();j++)
			{	Type archetype = tpt.getComposanteTPT(j).getType();
				if (!resultat.contains(archetype.getNom()))
					resultat.add(archetype.getNom());
			}
		}
		
		return resultat;
	}
	/**
	 * renvoie la vue permettant ŕ la GUI d'avoir accčs aux TPT de cette Section.
	 * Si la vue n'existe pas encore, elle est créée.
	 * 
	 * @return	la Vue des TPT de cette Section.
	  */
	public VueTPT getVueTPT()
	{	if (vueTPT == null)
			vueTPT = new VueTPT(this,vectorTPT);
		return vueTPT;
	}
	/**
	 * renvoie la vue permettant ŕ la GUI d'avoir accčs ŕ 
	 * l'archétype dont le nom est passé en paramčtre.
	 * Si la vue n'existe pas encore, elle est créée grâce ŕ 
	 * la méthode extraireVueArchetype.
	 * 
	 * @param	n	le nom de l'archétype dont on veut la vue.
	 * @return	la Vue de l'archétype dont le nom est passé en paramčtre.
	  */
	public VueType getVueArchetype(String n)
	{	if (tabVueArchetype == null)
		{	Vector temp = getListeArchetype();
			tabVueArchetype = new VueType[temp.size()];
			for (int i=0;i<temp.size();i++)
				tabVueArchetype[i] = extraireVueArchetype((String)temp.get(i));
		}
		
		boolean trouve = false;
		int i = 0;
		while (!trouve && i<tabVueArchetype.length)
		{	int j=0;
			while (tabVueArchetype[i].getType(j)==null)
				j++;
			if (n.equals(tabVueArchetype[i].getType(j).getNom()))
				trouve = true;
			else
				i++;
		}
		return tabVueArchetype[i];
	}
	/**
	 * construit la vue de l'archétype dont le nom est passé
	 * en paramčtre.
	 * 
	 * @param	n	le nom de l'archétype dont on veut construire la vue.
	 * @return	la Vue de l'archétype dont le nom est passé en paramčtre.
	  */
	public VueType extraireVueArchetype(String n)
	{	VectorType v = new VectorType();
		for (int i=0;i<vectorTPT.size();i++)
		{	TPT tpt = getTPT(i);
			if (tpt.containsNom(n))
				v.addType(tpt.getComposanteTPT(n).getType());
			else
				// on met null si l'archétype n'existe pas : ŕ traiter ds la vueType
				v.addType(null);
		}
		VueType resultat = new VueType(this,v);
		return resultat;
	}
	/*
	 * 
	 */
	public String getIdentification()
	{	return parent.getIdentification()+">"+Commun.STRING_APPRENTISSAGE;
	}

//	----------------------------------------	
//	Modification
//	----------------------------------------
	/*
	 * 
	 */
	public void setModifie()
	{	modifie = true;
	}
	/*
	 * 
	 */
	public boolean estModifie()
	{	return modifie;  
	}
	/*
	 * 
	 */
	public void setNonModifie()
	{	modifie = false;
		fonctionTPT.setNonModifie();
		getTPTInitiale().setNonModifie();
		fireTraitementRaffr(new TraitementEvent(this));
	}
	/**
	 * renvoie l'indicateur indiquant si un Noeud nécessaire 
	 * mais absent doit ętre créé.
	 * 
	 * @return	l'indicateur.
	 */
	public boolean getCreerNoeudSiAbsent()
	{	return getParent().getCreerNoeudSiAbsent();  
	}
}