/*
 * Créé le 25 nov. 2004
 *
 */
package traitement.noeud;

import java.util.Vector;

import principal.Commun;
import traitement.TraitementIncompletException;

/**
 * permet de définir des listes de Noeuds sous forme de vecteurs.
 * La manipulation est facilitée par rapport à l'utilisation directe de Vector.
 * De plus, certaines méthodes spécialement dédiées aux Noeuds sont rajoutées.
 * 
 * @author	Vincent Labatut
 * @version	1
 * @see		information.type.Type
  */
public class VectorNoeud
{	/**
	* Liste de Noeuds
	 */
	private Vector vectorNoeud;
	
//	----------------------------------------	
//	Constructeurs
//	----------------------------------------
	/**
	 * Constructeur pour créer un VectorNoeud vide.  
	 * 
	  */
	public VectorNoeud()
	{	vectorNoeud = new Vector();
	}

//	----------------------------------------	
//	Noeud
//	----------------------------------------
	/**
 	* renvoie un Noeud de ce VectorNoeud en fonction de son rang.
 	* 
 	* @param 	rang	rang du Noeud désiré.
 	* @return	le Noeud de rang 'rang'.
  	*/
	public InterfaceNoeud getNoeud(int rang)
	{	return((InterfaceNoeud) vectorNoeud.get(rang));
	}
	/**
 	* renvoie un Noeud de ce VectorNoeud en fonction de son nom.
 	* 
 	* @param 	nom	nom du Noeud désiré.
 	* @return	le Noeud de nom 'nom'.
  	*/
	public InterfaceNoeud getNoeud(String nom)
	{	int index = indexOf(nom);
		return getNoeud(index);
	}
	/**
	 * ajoute un Noeud dans ce VectorNoeud.
	 * 
	 * @param 	n	Noeud à ajouter à ce VectorNoeud.
	  */
	public void addNoeud(InterfaceNoeud n)
	{	vectorNoeud.add(n);
	}	
	/**
	 * insère un Noeud dans ce VectorNoeud, au rang précisé.
	 * 
	 * @param 	rang	rang où insérer ce Noeud dans ce VectorNoeud.
	 * @param 	n		Noeud à ajouter à ce VectorNoeud.
	  */
	public void addNoeud(int rang, InterfaceNoeud n)
	{	vectorNoeud.add(rang,n);
	}	
	/**
	 * remplace le Noeud de rang 'index' par le Noeud passé en paramètre,
	 * dans ce VectorNoeud.
	 * 
	 * @param 	rang	index du Noeud à remplacer.
	 * @param 	n		Noeud à substituer.
	  */
	public void setNoeud(int rang, InterfaceNoeud n)
	{	vectorNoeud.set(rang,n);
	}	
	/**
	 * supprime de ce VectorNoeud le Noeud passé en paramètre.
	 * 
	 * @param 	n	Noeud à supprimer.
	 * @throws	InformationIncompleteException si le Noeud passé en paramètre est incomplet.
	  */
	public void removeNoeud(InterfaceNoeud n) throws TraitementIncompletException
	{	int cible;
		
		cible = indexOf(n);
		if (cible >= 0)
			removeNoeud(cible);
	}	
	/**
	 * supprime un Noeud de ce VectorNoeud en fonction de son rang.
	 * 
	 * @param 	rang	rang du Noeud à supprimer.
	  */
	public void removeNoeud(int rang)
	{	vectorNoeud.removeElementAt(rang);
	}	
	/**
	 * renvoie le rang d'un Noeud de ce VectorNoeud.
	 * Le Noeud doit être complet.
	 * 
	 * @param 	n	Noeud dont on veut connaitre le rang.
	 * @return 	le rang du Noeud passé en paramètre.
	 * @throws	InformationIncompleteException si le Noeud passé en parametre est incomplet.
	  */
	public int indexOf(InterfaceNoeud n) throws TraitementIncompletException
	{	boolean resultat;
		int i;
		
		if (n.estVide())
			throw new TraitementIncompletException(n.getIdentification());
		i = 0;
		resultat = false;
		while (i<size() && !resultat)
		{	try
			{	if (getNoeud(i).egale(n))
					resultat = true;
				else
					i ++;
			}
			catch (TraitementIncompletException e)
			{	e.printStackTrace();
			}
		}		
		if (!resultat)
			i = -1;
		return(i);
	}	
	/**
	 * renvoie le rang d'un Noeud de ce VectorNoeud.
	 * Le Noeud doit être complet.
	 * 
	 * @param 	n	Noeud dont on veut connaitre le rang.
	 * @return 	le rang du Noeud passé en paramètre.
	 * @throws	InformationIncompleteException si le Noeud passé en parametre est incomplet.
	  */
	public int indexOf(String n)
	{	boolean resultat;
		int i;
		
		i = 0;
		resultat = false;
		while (i<size() && !resultat)
		{	try
			{	if (getNoeud(i).getNom().equals(n))
					resultat = true;
				else
					i ++;
			}
			catch (TraitementIncompletException e)
			{	e.printStackTrace();
			}
		}		
		if (!resultat)
			i = -1;
		return(i);
	}	
	/**
	 * détermine si un Noeud donné appartient à ce VectorNoeud.
	 * Le Noeud doit être complet.
	 * 
	 * @param 	n	Noeud dont on veut savoir s'il appartient à ce VectorNoeud.
	 * @return 	vrai si ce VectorNoeud contient le Noeud passé en paramètre, faux sinon.
	 * @throws	InformationIncompleteException si le Noeud passé en parametre est incomplet.
	  */
	public boolean contains(InterfaceNoeud n) throws TraitementIncompletException
	{	boolean resultat;
		int i;
		
		if (n.estVide())
			throw new TraitementIncompletException(n.getIdentification());
		i = 0;
		resultat = false;
		while (i<size() && !resultat)
		{	try
			{	if (getNoeud(i).egale(n))
					resultat = true;
				else
					i ++;
			}
			catch (TraitementIncompletException e)
			{	e.printStackTrace();
			}
		}		
		return(resultat);
	}
	/**
	 * détermine si un Noeud de nom donné appartient à ce VectorNoeud,
	 * en fonction de son nom.
	 * 
	 * @param 	n	nom du Noeud dont on veut savoir s'il appartient à ce VectorNoeud.
	 * @return 	vrai si ce VectorNoeud contient un Noeud du nom passé en paramètre, faux sinon.
	  */
	public boolean contains(String n)
	{	boolean resultat;
		int i;
		InterfaceNoeud e2;
		
		i = 0;
		resultat = false;
		while (i<size() && !resultat)
		{	try
			{	e2 = getNoeud(i);
				if (!e2.estVide())
					if (e2.getNom().equals(n))
						resultat = true;
					else
						i ++;
			}
			catch (TraitementIncompletException exception)
			{	i++;
			}
		}		
		return(resultat);
	}	

//	----------------------------------------	
//	This
//	----------------------------------------
	/**
	 * renvoie la taille de ce VectorNoeud.
	 * La taille d'un VectorNoeud correspond au nombre de Noeuds qu'il contient.  
	 * 
	 * @return 	le nombre de Noeuds dans ce VectorNoeud.
	  */
	public int size()
	{	return(vectorNoeud.size());
	}

//	----------------------------------------	
//	Simulation
//	----------------------------------------
	/**
	 * détermine si ce VectorNoeud est complètement défini.
	 * Cette méthode est appellée juste avant la simulation.
	 * Un VectorNoeud est complet si tous les Noeuds qu'il 
	 * contient sont complets. 
	 * 
	 * @return 	vrai si ce VectorNoeud est complètement défini.
	  */
	public boolean estComplet()
	{	boolean resultat;
		int taille,i;
		InterfaceNoeud e;
		
		taille = size();
		i = 0;
		resultat = true;
		while (i<taille && resultat)
		{	e = getNoeud(i);
			if (e == null)
				resultat = false;
			else
				resultat = resultat && e.estComplet();
			i++;
		}
		return(resultat); 
	}
	
//	----------------------------------------	
//	Divers
//	----------------------------------------
	/*
	 * 
	  */
	public String toString()
	{	StringBuffer resultat;
		int i;
		InterfaceNoeud e;
		
		resultat = new StringBuffer();
		resultat.append("[ ");
		for (i=0;i<vectorNoeud.size();i++)
		{	e = getNoeud(i);
			try
			{	resultat.append(e.getNom());
			}
			catch (TraitementIncompletException e1)
			{	resultat.append(Commun.STRING_VIDE);
			}
			if (i<size()-1)
				resultat.append(", ");
		}
		resultat.append(" ]");
		return(resultat.toString());
	}
}