/*
 * Crťť le 17 aoŻt 2004
 *
 */
package traitement.section;

import information.DomaineIncompatibleException;
import information.domaine.InterfaceDomaine;
import information.magnitude.Magnitude;
import information.type.Type;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import principal.Commun;
import principal.copiercoller.CopiableIncompatibleException;
import principal.copiercoller.InterfaceCopiable;
import principal.copiercoller.Tampon;

import fichier.ContenuFichierIncompatibleException;
import fichier.TypeFichierIncompatibleException;
import fichier.VersionFichierIncompatibleException;
import fichier.flux.RageOutputStream;
import fonction.FonctionEvent;
import fonction.FonctionListener;
import fonction.InterfaceFonctionFils;
import fonction.magnitude.InterfaceFonctionFilsMagnitude;
import fonction.magnitude.InterfaceFonctionParentMagnitude;
import fonction.magnitude.MagnitudeBruit;
import fonction.type.InterfaceFonctionFilsType;
import fonction.type.InterfaceFonctionParentType;
import fonction.type.TypeVide;
import gui.InterfaceAffichable;
import traitement.TraitementEvent;
import traitement.noeud.fonctionnel.AbstractNoeudFonctionnelPlein;
import traitement.noeud.fonctionnel.NoeudFonctionnelEndogene;

/**
 * constituants des NoeudEndogenes.
 * Ce type de Section est utilisť pour gťrer les parties d'activation ou d'ťmission d'un NoeudFonctionnelEndogene.
 * Une SectionInformationEndogene possŤde son propre Domaine, et des historiques de Magnitudes et de Types
 * sous la forme d'un VectorMagnitude et d'un VectorType.
 * Elle possŤde ťgalement des fonction de magnitude et de type, et peut gťrer un fichier d'observation.
 * 
 * @author	Vincent Labatut
 * @version	1
 * @see		traitement.noeud.fonctionnel.NoeudFonctionnelEndogene
 * @see		traitement.section.SectionApprentissage
  */

public abstract class AbstractSectionInformationEndogene extends AbstractSectionInformation implements FonctionListener, InterfaceFonctionParentMagnitude, InterfaceFonctionParentType
{	/**
	 * Fonction de magnitude.
	  */
	protected InterfaceFonctionFilsMagnitude fonctionMagnitude;
	/**
	 * Fonction de type.
	  */
	protected InterfaceFonctionFilsType fonctionType;
	/**
	 * Editeur de fichier d'observation.
	  */
	protected EditeurObservation observationEditeur;
	/**
	 * Nombre de fonction magnitude
	  */
	protected static int MAX_MAG = 1;
	/**
	 * Nombre de fonction type
	  */
	protected static int MAX_TYPE = 1;
	/**
	 * Index de la fonction magnitude
	  */
	protected static int INDEX_MAG = 0;
	/**
	 * Index de la fonction type
	  */
	protected static int INDEX_TYPE = 1;

	protected File repertoireObservation;

//	----------------------------------------	
//	EditeurObservation
//	----------------------------------------
	/**
	 * renvoie l'ťditeur d'observation de cette Section.
	 * 
	 * @return	l'EditeurObservation de cette Section.
	  */
	public EditeurObservation getObservationEditeur()
	{	return observationEditeur;
	}
	/**
	 * remplace l'ťditeur d'observation de cette Section par
	 * celui passť en paramŤtre.
	 * Emission de TraitementEvent de complťtude et de raffraichissement
	 * 
	 * @param	editeur	le nouvel ťditeur d'observation de cette Section.
	  */
	public void setObservationEditeur(EditeurObservation editeur) throws IOException
	{	observationEditeur.removeTraitementListener(this);
		observationEditeur.remove();
		observationEditeur = editeur;
		observationEditeur.addTraitementListener(this);
		observationEditeur.setParent(this);
		setModifie();
	    fireTraitementRaffr(new TraitementEvent(this));
	}
	/**
	 * permet de savoir si la Magnitude est observable.
	 * Si c'est le cas, il faut lui associer un fichier contenant les observations.
	 * 
	 * @return	vrai si la Magnitude est observable, faux sinon.
	  */
	public boolean estObservable()
	{	return observationEditeur.estObservable();
	}
	/**
	 * permet de basculer la Magnitude d'activation en mode observable ou non observable.
	 * 
	 * @param	flag	si le flag est vrai, la Magnitude devient observable.
	 * 					Sinon, elle devient non-observable.
	  */
	public void setObservable(boolean flag)
	{	observationEditeur.setObservable(flag);
	}
	/**
	 * renvoie le dernier fichier dťsignť pour l'observation de la Magnitude.
	 * 
	 * @return	le fichier d'observation de la Magnitude.
	  */
	public File getObservationFichier()
	{	return observationEditeur.getObservationFichier();
	}
	/**
	 * remplace l'ancien fichier d'observation de la Magnitude par celui passť en paramŤtre.
	 * 
	 * @param	f	le nouvau fichier d'observation de la Magnitude d'activation.
	 * @throws	IOException si une erreur se produit lors de la vťrification du fichier.
	 * @throws	ClassNotFoundException une erreur se produit lors de la vťrification du fichier.
	 * @throws	VersionFichierIncompatibleException le fichier n'est pas d'une version compatible.
	 * @throws	TypeFichierIncompatibleException le fichier n'est pas un fichier d'observation.
	 * @throws	ContenuFichierIncompatibleException  le contenu du fichier est erronť.
	  */
	public void setObservationFichier(File f) throws IOException, ContenuFichierIncompatibleException, VersionFichierIncompatibleException, TypeFichierIncompatibleException
	{	observationEditeur.setObservationFichier(f);
	}
	/**
	 * rťinitialise le fichier d'observation ŗ null.
	 * 
	  */
	public void removeObservationFichier()
	{	observationEditeur.removeObservationFichier();
	}
	/**
	 * teste si le fichier passť en paramŤtre est valide 
	 * pour devenir le fichier d'observation.
	 * Structure d'un fichier d'observation :
	 *	- String : version
	 *	- String : type de fichier
	 *	- Integer : instant de l'observation
	 *	- Magnitude : (magnitude d'activation ou d'ťmission) n fois
	 *
	 * @param	f	le fichier d'observation ŗ tester.
	 * @return : la taille du fichier.
	 * @throws	IOException si une erreur se produit lors de la vťrification du fichier.
	 * @throws	ClassNotFoundException une erreur se produit lors de la vťrification du fichier.
	 * @throws	VersionFichierIncompatibleException le fichier n'est pas d'une version compatible.
	 * @throws	TypeFichierIncompatibleException le fichier n'est pas un fichier d'observation.
	 * @throws	ContenuFichierIncompatibleException  le contenu du fichier est erronť.
	  */
	public int testerObservationFichier(File f) throws IOException, ClassNotFoundException, VersionFichierIncompatibleException, TypeFichierIncompatibleException, ContenuFichierIncompatibleException
	{	return observationEditeur.testerObservationFichier(f);
	}
	/**
	 * crťe un nouveau fichier d'observation de la Magnitude.
	 * Ce fichier est vide d'observations.
	 * 
	 * @throws	IOException si une erreur se produit lors de la vťrification du fichier.
	 * @throws	ClassNotFoundException une erreur se produit lors de la vťrification du fichier.
	 * @throws	VersionFichierIncompatibleException le fichier n'est pas d'une version compatible.
	 * @throws	TypeFichierIncompatibleException le fichier n'est pas un fichier d'observation.
	 * @throws	ContenuFichierIncompatibleException  le contenu du fichier est erronť.
	  */
	public void newObservationFichier() throws IOException
	{	observationEditeur.newObservationFichier();
	}
	/**
	 * permet de savoir s'il existe une observation pour la Magnitude
	 * ŗ un instant donnť. En effet, l'observation n'est pas systťmatique ŗ chaque
	 * instant, il est possible de se passer d'observations ŗ certains instants.
	 * 
	 * @param	instant	instant pour lequel on veut savoir s'il existe une observation.
	 * @return	vrai s'il existe une observation ŗ cet instant, faux sinon.
	 * @throws	IOException si une erreur se produit lors de la vťrification du fichier.
	 * @throws	ClassNotFoundException une erreur se produit lors de la vťrification du fichier.
	  */
	public boolean estObservable(int instant) throws IOException, ClassNotFoundException
	{	return observationEditeur.estObservable(instant);
	}
	/**
	 * renvoie l'observation de la Magnitude ŗ un instant donnť.
	 * 
	 * @param	instant	instant pour lequel on veut obtenir l'observation.
	 * @return	Magnitude observťe ŗ l'instant passť en paramŤtre.
	 * @throws	IOException si une erreur se produit lors de la vťrification du fichier.
	 * @throws	ClassNotFoundException une erreur se produit lors de la vťrification du fichier.
	  */
	public Magnitude getObservationValeur(int instant) throws IOException, ClassNotFoundException
	{	return observationEditeur.getObservationValeur(instant);					
	}
	/**
	 * lit l'observation de la Magnitude d'emission de l'instant suivant
	 * (et le numťro de l'instant lui mÍme),
	 * dans le fichier d'observation.
	 * 
	 * @throws	IOException si une erreur se produit lors de la vťrification du fichier.
	 * @throws	ClassNotFoundException une erreur se produit lors de la vťrification du fichier.
	  */
	public void lireObservation() throws IOException, ClassNotFoundException
	{	observationEditeur.lireObservation();
	}
	/**
	 * enregistre le contenu de l'Editeur dans 
	 * le fichier.
	 * @throws	IOException	si une erreur se produit durant l'ťcriture.
	 * 
	  */
	public void enregistrerObservationFichier() throws IOException
	{	observationEditeur.enregistrerObservationFichier();
	}

	public void exporterObservationFichier(File fichier) throws IOException
	{	observationEditeur.exporterObservationFichier(fichier);
	}

//	----------------------------------------	
//	Parent
//	----------------------------------------
	/*
	 * modifie le NoeudFonctionnelEndogene qui contient cette SectionInformationEndogene
	 * (i.e. son parent).
	 * Cette modification peut impliquer un changement de Modele, et est propagťe
	 * aux fonctions.
	  */
	public void setParent(AbstractNoeudFonctionnelPlein n)
	{	super.setParent(n);
		fonctionMagnitude.setParent(this);		
		fonctionType.setParent(this);	
		try
		{	raffraichirRepertoireObservation();
		}
		catch (IOException e)
		{	e.printStackTrace();
		}
	}

//	----------------------------------------	
//	  This
//	----------------------------------------
	/*
	 *
	 */
	public void remove()
	{	fireTraitementSuppr(new TraitementEvent(this));
		//
		getMagnitudeInitiale().removeInformationListener(this);
		while (vectorMagnitude.size() != 0)
		{	vectorMagnitude.getMagnitude(0).remove();
			vectorMagnitude.removeMagnitude(0);
		}
		vectorMagnitude = null;
		//
		getTypeInitial().removeInformationListener(this);
		while (vectorType.size() != 0)
		{	vectorType.getType(0).remove();
			vectorType.removeType(0);
		}
		vectorType = null;
		// fonctionMagnitude
		fonctionMagnitude.removeFonctionListener(this);
		fonctionMagnitude.remove();
		fonctionMagnitude = null;
		// fonctionType
		fonctionType.removeFonctionListener(this);
		fonctionType.remove();
		fonctionType = null;
		// observationEditeur
		observationEditeur.removeTraitementListener(this);
		observationEditeur.remove();
		observationEditeur = null;
		// domaine
		domaine.removeInformationListener(this);
		domaine.remove();
		domaine = null;
		// 
		parent = null;
		//
		if (vueType != null)
			vueType.remove();
		if (vueMagnitude != null)
			vueMagnitude.remove();
		//		
	}

//	----------------------------------------	
//	  InterfaceParent
//	----------------------------------------
	/*
	 * renvoie le fils numťro 'rang' sans tenir compte du type de fils.
	 * 
	  */
	public InterfaceFonctionFils getFils(int rang)
	{	if (rang == INDEX_MAG)
			return fonctionMagnitude;
		else
			return fonctionType;
	}
	/*
	 * 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) throws DomaineIncompatibleException
	{	if (rang == INDEX_MAG)
			setFonctionMagnitude((InterfaceFonctionFilsMagnitude)fils);
		else
			setFonctionType((InterfaceFonctionFilsType)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)
	{	//	
	}
	/*
	 * remplace le fils passť en premier paramŤtre
	 * par un nouveau fils passť en second paramŤtre
	 * sans tenir compte du type de fils.
	 * 
	  */
	public void remplacerFils(InterfaceFonctionFils ancien, InterfaceFonctionFils nouveau) throws DomaineIncompatibleException
	{	if (ancien == fonctionMagnitude)
			setFonctionMagnitude((InterfaceFonctionFilsMagnitude)nouveau);
		else if (ancien == fonctionType)
			setFonctionType((InterfaceFonctionFilsType)nouveau);
	}
	/*
	 * supprime un fils passť en paramŤtre
	 * sans tenir compte du type de fils.
	 * On ne peut pas supprimer ici, mais on 
	 * peut remplacer par un fils vide.
	 * 
	  */
	public void removeFils(InterfaceFonctionFils fils)
	{	if (fils instanceof InterfaceFonctionFilsMagnitude)
			setFonctionMagnitude(new MagnitudeBruit(this));
		else if (fils instanceof InterfaceFonctionFilsType)
		{	try
			{	setFonctionType(new TypeVide(domaine,this));
			}
			catch (DomaineIncompatibleException e)
			{	e.printStackTrace();
			}
		}
	}
	/*
	 * supprime un fils dont le rang est passť en paramŤtre
	 * sans tenir compte du type de fils.
	 * On ne peut pas supprimer ici, mais on 
	 * peut remplacer par un fils vide.
	 * 
	  */
	public void removeFils(int rang)
	{	if (rang == INDEX_MAG)
			setFonctionMagnitude(new MagnitudeBruit(this));
		else
		{	try
			{	setFonctionType(new TypeVide(domaine,this));
			}
			catch (DomaineIncompatibleException e)
			{	e.printStackTrace();
			}
		}
	}
	/*
	 * renvoie le nombre de fils 
	 * sans tenir compte du type de fils.
	 * 
	  */
	public int sizeFils()
	{	return MAX_TYPE+MAX_MAG;
	}
	/*
	 * renvoie la position d'un fils
	 * sans tenir compte du type de fils.
	 * 
	  */
	public int indexOfFils(InterfaceFonctionFils fils)
	{	if (fils == fonctionMagnitude)
			return INDEX_MAG;
		else if (fils == fonctionType)
			return INDEX_TYPE;
		else
			return -1;
	}
	/*
	 * transmet la modification d'un fils vers les propres parent de cette fonction.
	 * 
	  */
	public void traiterEltModif(int cat, int type, int index)
	{	//inutile ici
	}

//	----------------------------------------	
//	InterfaceParentType
//	----------------------------------------
	/*
	 *
	 */
	public InterfaceDomaine getDomainePourFils(InterfaceFonctionFilsType fils)
	{	return domaine;
	}

//	----------------------------------------	
//	FonctionListener
//	----------------------------------------
	/*
	 * appelťe lors de la rťception d'un FonctionEvent de suppression.
	 * Cette SectionInformationEndogene ťcoute ses deux fonctions.
	 * 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 SectionInformationEndogene ťcoute ses deux fonctions.
	 * 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 SectionInformationEndogene ťcoute ses deux fonctions.
	 * On lŤve 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.
	 * Cette SectionInformationEndogene ťcoute ses deux fonctions.
	 * On lŤve un TraitementEvent de raffraichissement
	  */
	public void fonctionRempl(FonctionEvent e)
	{	
	}
	/*
	 * appelťe lors de la rťception d'un FonctionEvent de masquage.
	 * Cette SectionInformationEndogene ťcoute ses deux fonctions.
	 * On lŤve un TraitementEvent de raffraichissement
	  */
	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 InterfaceFonctionFilsType)
			{	try
				{	fonctionType = new TypeVide(domaine, this);
				}
				catch (DomaineIncompatibleException e1)
				{	e1.printStackTrace();
				}
				fonctionType.addFonctionListener(this);
			}
			else if (temp instanceof InterfaceFonctionFilsMagnitude)
			{	fonctionMagnitude = new MagnitudeBruit(this);	
				fonctionMagnitude.addFonctionListener(this);
			} 
		} 
	}
				
//	----------------------------------------	
//	Simulation
//	----------------------------------------
	/*
	 * dťtermine si cette SectionInformationEndogene est complŤtement dťfinie.
	 * Cette mťthode est appellťe juste avant la simulation.
	 * Une SectionInformationEndogene est complete si son domaine est complet, 
	 * si ses historiques contiennent au moins
	 * un ťlťment chacun, et que ces ťlťments sont complets,
	 * si ses deux fonctions sont complŤtes
	 * et enfin si elle est observable alors le fichier d'observation
	 * doit Ítre valide. 
	  */
	public boolean estComplet()
	{	boolean resultat;
		
		resultat = super.estComplet();
		if (!fonctionMagnitude.estComplet())
				resultat = false;
		else if (!fonctionType.estComplet())
				resultat = false;
		else if (!observationEditeur.estComplet())
				resultat = false;
		return(resultat);
	}
	/*
	 * dťtermine si cette Section est complŤtement dťfinie.
	 * Elle est destinťe ŗ Ítre appelťe par la GUI, et par consťquent 
	 * les tests effectuťs sont moins stricts que dans le cas de la
	 * mťthode estComplet, qui est, elle, destinťe ŗ prťvenir la simulation
	 * de tout problŤme. En particulier, ici, on ne teste pas le contenu
	 * des fichiers dans la mťthode.
	  */
	public boolean estCompletInterface()
	{	boolean resultat;
		
		resultat = super.estComplet();
		if (!fonctionMagnitude.estComplet())
				resultat = false;
		else if (!fonctionType.estComplet())
				resultat = false;
		else if (!observationEditeur.estCompletInterface())
				resultat = false;
		return(resultat);
	}
	/**
	 * 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() throws IOException, ContenuFichierIncompatibleException, VersionFichierIncompatibleException, TypeFichierIncompatibleException
	{	if (estObservable())
			observationEditeur.interrompreSimulation();
		effacerHistorique();
	}
	/**
	 * 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, ContenuFichierIncompatibleException, VersionFichierIncompatibleException, TypeFichierIncompatibleException
	{	// on enregistre les rťsultats de Type
		File fichier = new File
			(	getRepertoireSimulation().getPath()
				+"-"+Commun.STRING_TYPE
				+Commun.EXT_RESULTAT);
		FileOutputStream out = null;
		RageOutputStream outputStream;
		try
		{	out = new FileOutputStream(fichier);
			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(getDomaine());
			// la taille du Vector ŗ ťcrire
			outputStream.writeObject(new Integer(vectorType.size()));
			// et enfin chaque information			
			for (int i=0;i<vectorType.size();i++)
				outputStream.writeType(vectorType.getType(i));
			out.close();
		}
		catch (FileNotFoundException e)
		{	if (out != null)
				out.close();
			effacerHistorique();
			if (estObservable())
				observationEditeur.terminerSimulation();
			throw e;
		}
		catch (IOException e)
		{	if (out != null)
				out.close();
			effacerHistorique();
			if (estObservable())
				observationEditeur.terminerSimulation();
			throw e;
		}

		// on enregistre les rťsultats de Magnitude
		fichier = new File
			(	getRepertoireSimulation().getPath()
				+"-"+Commun.STRING_MAGNITUDE
				+Commun.EXT_RESULTAT);
		try
		{	out = new FileOutputStream(fichier);
			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);
			// la taille du Vector ŗ ťcrire
			outputStream.writeObject(new Integer(vectorMagnitude.size()));
			// et enfin chaque information			
			for (int i=0;i<vectorMagnitude.size();i++)
				outputStream.writeMagnitude(vectorMagnitude.getMagnitude(i));
			out.close();
		}
		catch (FileNotFoundException e)
		{	if (out != null)
				out.close();
			effacerHistorique();
			if (estObservable())
				observationEditeur.terminerSimulation();
			throw e;
		}
		catch (IOException e)
		{	if (out != null)
				out.close();
			effacerHistorique();
			if (estObservable())
				observationEditeur.terminerSimulation();
			throw e;
		}
		//
		effacerHistorique();		
		//
		if (estObservable())
			observationEditeur.terminerSimulation();
					
	}

//	----------------------------------------	
//	  Copier/Coller
//	----------------------------------------
	/*
	 * colle dans cette SectionInformationEndogene un Type ou une Magnitude contenue dans le Tampon, 
	 * qui vient remplacer le Type ou la Magnitude inital.
	 * Le Domaine ne peut pas Ítre collť.
	 * On peut ťgalement coller une fonction.
	 * Une ObjetRageIncompatibleException est levťe si l'objet n'est 
	 * pas une Magnitude ou un Type, 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 Type)
		{	Type temp = (Type) buffer;
			try
			{	setTypeInitial(temp);
			}
			catch (DomaineIncompatibleException e)
			{	throw new CopiableIncompatibleException(getIdentification());
			}					
		}
		else if (buffer instanceof Magnitude)
		{	Magnitude temp = (Magnitude) buffer;
			setMagnitudeInitiale(temp);
		}
		else
			throw new CopiableIncompatibleException(getIdentification());
	}

//	----------------------------------------	
//	InterfaceAffichable
//	----------------------------------------
	/*
	 *
	 */
	public void remplacer(InterfaceAffichable a)
	{	AbstractSectionInformationEndogene sif = (AbstractSectionInformationEndogene) a;
		getMagnitudeInitiale().remplacer(sif.getMagnitudeInitiale());
		//
		getTypeInitial().remplacer(sif.getTypeInitial());
		// fonctionMagnitude
		fonctionMagnitude.remplacer(sif.getFonctionMagnitude());
		// fonctionType
		fonctionType.remplacer(sif.getFonctionType());
		// Observation
		observationEditeur.cacher();
		// domaine
		domaine.remplacer(sif.getDomaine());
		//
		fireTraitementRempl(new TraitementEvent(this,(AbstractSectionInformationEndogene)a));
	}
	/*
	 *
	 */
	public void cacher()
	{	getMagnitudeInitiale().cacher();
		//
		getTypeInitial().cacher();
		// fonctionMagnitude
		fonctionMagnitude.cacher();
		// fonctionType
		fonctionType.cacher();
		// Observation
		observationEditeur.cacher();
		// domaine
		domaine.cacher();
		//
		fireTraitementCache(new TraitementEvent(this));
	}

//	----------------------------------------	
//	Fonction
//	----------------------------------------
	/**
	 * renvoie l'InterfaceFonctionMagnitude remplissant le rŰle
	 * de fonction de Magnitude.
	 * 
	 * @return 	la fonction de Magnitude.
	  */
	public InterfaceFonctionFilsMagnitude getFonctionMagnitude()
	{	return fonctionMagnitude;
	}
	/**
	 * renvoie l'InterfaceFonctionType remplissant le rŰle
	 * de fonction de Type.
	 * 
	 * @return 	la fonction de Type.
	  */
	public InterfaceFonctionFilsType getFonctionType()
	{	return fonctionType;
	}
	/**
	 * substitue une nouvelle InterfaceFonctionMagnitude, passťe en
	 * paramŤtre, ŗ de fonction de Magnitude.
	 * Emission de TraitementEvents de raffraichissement et de complťtude.
	 * 
	 * @param 	fct	la nouvelle fonction de Magnitude.
	  */
	public void setFonctionMagnitude(InterfaceFonctionFilsMagnitude fct)
	{	fonctionMagnitude.removeFonctionListener(this);
		fonctionMagnitude.remplacer(fct);
		fonctionMagnitude.remove();
		fonctionMagnitude = fct;
		fonctionMagnitude.addFonctionListener(this);
		fonctionMagnitude.setParent(this);
		setModifie();
	    fireTraitementEltModif(new TraitementEvent(this,TraitementEvent.ELT_REMPL,INDEX_MAG));
	}
	/**
	 * substitue une nouvelle InterfaceFonctionType, passťe en
	 * paramŤtre, ŗ de fonction de Type.
	 * Emission de TraitementEvents de raffraichissement et de complťtude.
	 * 
	 * @param 	fct	la nouvelle fonction de Type.
	  */
	public void setFonctionType(InterfaceFonctionFilsType fct) throws DomaineIncompatibleException
	{	if (!domaine.estCompatibleDomaine(fct.getDomaine()))
			throw new DomaineIncompatibleException(getIdentification()+":"+fct.getIdentification());
		fonctionType.removeFonctionListener(this);
		fonctionType.remplacer(fct);
		fonctionType.remove();
		fonctionType = fct;
		fonctionType.addFonctionListener(this);
		fonctionType.setParent(this);
		setModifie();
	    fireTraitementEltModif(new TraitementEvent(this,TraitementEvent.ELT_REMPL,INDEX_TYPE));
	}
	/*
	 *
	 */
	public NoeudFonctionnelEndogene getNoeud()
	{	return (NoeudFonctionnelEndogene) parent;
	}
	/**
	 * clone les fonctions de la Section passťe en paramŤtre et les affecte
	 * ŗ cette Section. Cette mťthode est utilisťe par la mťthode Section.cloner.
	 * En effet, en raison des rťfťrences ŗ des Noeuds eventuellement contenues dans
	 * les fonctions, et en particulier des auto-rťfťrences (sur le Noeud qui contient
	 * lui-mÍme la fonction), il n'est pas possible de cloner en une seule fois le Domaine,
	 * l'historique, etc., et les fonctions. Cette mťthode sert donc ŗ cloner les fonctions
	 * a posteriori.  
	 * 
	 * @param	section	la Section dont on veut cloner les fonctions.
	 * 
	  */
	public void clonerFonction(AbstractSectionInformationEndogene section)
	{	// Fils
		setFonctionMagnitude(((InterfaceFonctionFilsMagnitude)section.getFonctionMagnitude().cloner()));
		try
		{	setFonctionType(((InterfaceFonctionFilsType)section.getFonctionType().cloner()));
		}
		catch (DomaineIncompatibleException e)
		{	e.printStackTrace();
		}
		setNonModifie();
	}
	/**
	 * renvoie le rťpertoire contenant le fichier d'observation de cette Section.  
	 * 
	 * @return	le rťpertoire du fichier d'observation.
	 * 
	  */
	public File getRepertoireObservation()
	{	return repertoireObservation;
	}
	/**
	 * rťcupŤre le rťpertoire d'observation du parent et le complŤte de maniŤre
	 * ŗ construire le rťpertoire d'observation de cette Section.  
	 * 
	 * @throws	IOException	si une erreur se produit lors de l'accŤs au rťpertoire.
	 * 
	  */
	public abstract void raffraichirRepertoireObservation() throws IOException;
	/**
	 * renvoie vrai si cette Section est observťe, i.e. dispose d'un fichier
	 * d'observation.  
	 *
	 * @return	vrai si cette Section est observťe. 
	  */
	public boolean estObservationFichierAffecte()
	{	return observationEditeur.estObservationFichierAffecte();
	}
	/**
	 * modifie l'indicateur d'observation de cette Section ŗ vrai ou faux suivant
	 * la valeur passťe en paramŤtre.  
	 *
	 * @param	flag	nouvelle valeur de l'indicateur d'observation. 
	  */
	public void setObservationFichierAffecte(boolean flag) throws IOException, ClassNotFoundException, VersionFichierIncompatibleException, TypeFichierIncompatibleException, ContenuFichierIncompatibleException
	{	observationEditeur.setObservationFichierAffecte(flag);
	}

//	----------------------------------------	
//	Modification
//	----------------------------------------
	/*
	 *
	 */
	public void setNonModifie()
	{	modifie = false;
		getMagnitudeInitiale().setNonModifie();
		getTypeInitial().setNonModifie();
		fonctionMagnitude.setNonModifie();
		fonctionType.setNonModifie();
		observationEditeur.setNonModifie();
		domaine.setNonModifie();
		fireTraitementRaffr(new TraitementEvent(this));
	}
  
//	----------------------------------------	
//	TraitementListener
//	----------------------------------------
	/*
	 * appelťe lors de la rťception d'un TraitementEvent de raffraichissement.
	 * La SectionInformationExogene ťcoute son EditeurEntree.
	 * On transmet l'ťvŤnement.
	  */
	public void traitementRaffr(TraitementEvent e)
	{	if (e.getSource().estModifie())
		{    setModifie();
			fireTraitementRaffr(new TraitementEvent(this));
		}
	}
}