Task.java

package buffalo.dataStructures;

import java.util.Vector;

/**
  Une <CODE>T&acirc;che</CODE> est une entit&eacute; 
  effectuant des <CODE>Op&eacute;rations</CODE> sur des 
  <CODE>Buffers</CODE>, l'ordre de ces <CODE>Op&eacute;rations</CODE>, 
  les choix des <CODE>Buffers</CODE> sur lesquels les faire 
  ainsi que les dimensions de ces derniers peuvent ou non occasionner 
  des interblocages. 
  Ceux-ci r&eacute;sultant soit d'une tentative de lecture 
  dans un <CODE>Buffer</CODE> vide, soit d'une tentative 
  d'&eacute;criture dans un <CODE>Buffer</CODE> plein.
  <BR>
  <BR>
  Une <CODE>T&acirc;che</CODE> a plusieurs 
  caract&eacute;ristiques, &agrave; savoir&nbsp;:
  <UL>
  <LI>
  Une suite d'<CODE>Op&eacute;rations</CODE>.
  </LI>
  <LI>
  Une s&eacute;rie de <CODE>Buffers</CODE> connect&eacute;s en 
  &eacute;criture.
  </LI>
  <LI>
  Une s&eacute;rie de <CODE>Buffers</CODE> connect&eacute;s en lecture.
  </LI>
  </UL>
*/


public class Task
{

    /*
      Tableau des instances de cette classe.
    */

    private static Vector tasks;

    /*
     Tableau des op&eacute;rations à effectuer par cette t&acirc;che
    */

    private Vector operations;

    /*
      Tableau des buffers sur lesquels la t&acirc;che est 
      susceptible de lire
     */

    private Vector readBuffers;

    /*
      Tableau des buffers sue lesquels la t&acirc;che 
      est susceptible d'&eacute;crire
    */

    private Vector writeBuffers;

    /*
      L'index de l'instance courante de Task
     */

    private int indexOfMe;

    /*-------------------------------------------------------*/

    /*
      constructeur priv&eacute;
     */

    private Task()
    {
	if(tasks == null)
	    {
		tasks = new Vector();
	    }
	indexOfMe = tasks.size();
	operations = new Vector();
	readBuffers = new Vector();
	writeBuffers = new Vector();
    }

    /*-------------------------------------------------------*/
    
    /*
      Accesseurs de tous types!!
     */
    
    /**
      Retourne la <CODE>indexOfTask</CODE>-ième 
      <CODE>T&acirc;che</CODE> instanci&eacute;e.
     */

    public static Task get(int indexOfTask)
    {
	return (Task)(tasks.get((int)indexOfTask));
    }

    /*-------------------------------------------------------*/

    /**
      Retourne le nombre de <CODE>T&acirc;che</CODE> instanci&eacute;es.
     */

    public static int getNbTasks()
    {
	return tasks.size();
    }

    /*-------------------------------------------------------*/

    /**
      Cr&eacute;e une <CODE>T&acirc;che</CODE> et la renvoie 
      si sa cr&eacute;ation a &eacute;t&eacute; autoris&eacute;e.
    */
    
    static Task createTask()
    {
	Task newTask = new Task();
	tasks.add(newTask);
	return newTask;
    }

    /*-------------------------------------------------------*/

    /**
      Ajoute &agrave; la <CODE>T&acirc;che</CODE> courante 
      une <CODE>Op&eacute;ration</CODE> sur le 
      <CODE>Buffer</CODE> d'indice <CODE>indexOfBuffer</CODE>.
     */
    
    void addOperation(int indexOfBuffer)
    {
	operations.add(new Operation(indexOfBuffer, 
				     this.indexOfMe, 
				     operations.size()));
    }

    /*-------------------------------------------------------*/

    /**
      Renvoie la <CODE>indexOfOperation</CODE>-ième 
      <CODE>Op&eacute;ration</CODE> de la <CODE>T&acirc;che</CODE> 
      courante.
     */

    public Operation getOperation(int indexOfOperation)	
    {
	return (Operation)(operations.get((int)indexOfOperation));
    }

    /*-------------------------------------------------------*/

    /**
      Connecte les deux <CODE>T&acirc;ches</CODE> 
      d'indices respectifs <CODE>indexOfWritingTask</CODE> et 
      <CODE>indexOfReadingTask</CODE> avec le 
      <CODE>Buffer</CODE> d'indice <CODE>indexOfBuffer</CODE>.
     */
    
    static void connectWithBuffer(int indexOfWritingTask, 
				  int indexOfReadingTask, 
				  int indexOfBuffer)
    {
	((Task)tasks.get((int)indexOfReadingTask)).addReadBuffer(indexOfBuffer);
	((Task)tasks.get((int)indexOfWritingTask)).addWriteBuffer(indexOfBuffer);
    }

    /*-------------------------------------------------------*/

    /**
      Ajoute le <CODE>Buffer</CODE> d'indice <CODE>indexOfBuffer</CODE> 
      &agrave; la liste des buffers en lecture de la 
      <CODE>T&acirc;che</CODE> courante.<BR> Cette m&eacute;thode se 
      charge de mettre en place le chaînage double ou de 
      v&eacute;rifier si cela est d&eacute;j&agrave; fait.
     */
    
    private void addReadBuffer(int indexOfBuffer)
     {
	 readBuffers.add(Buffer.get(indexOfBuffer));
     }

    /*-------------------------------------------------------*/

    /**
      Ajoute le <CODE>Buffer</CODE> d'indice <CODE>indexOfBuffer</CODE> 
      &agrave; la liste des buffers en ecriture de la 
      <CODE>T&acirc;che</CODE> courante. <BR>Cette 
      m&eacute;thode se charge de mettre en place le chaînage 
      double ou de v&eacute;rifier si cela est d&eacute;j&agrave; fait.
    */

    private void addWriteBuffer(int indexOfBuffer)
     {
	 writeBuffers.add(Buffer.get(indexOfBuffer));
     }

    /*-------------------------------------------------------*/

    /**
      Renvoie l'indice de l'instance courante de <CODE>T&acirc;che</CODE>.
     */
    
    public int getIndex()
    {
	return indexOfMe;
    }

    /*-------------------------------------------------------*/

    /**
       Renvoie le <CODE>indexOfBuffer</CODE>-ième 
       <CODE>Buffer</CODE> connect&eacute; en lecture sur la 
       <CODE>T&acirc;che</CODE> courante.
     */
    
    public Buffer getReadBuffer(int indexOfBuffer)
    {
	return (Buffer)(readBuffers.get((int)indexOfBuffer));
    }

   /*-------------------------------------------------------*/

    /**
       Renvoie le nombre de <CODE>Buffers</CODE> 
       connect&eacute;s en lecture sur la 
       <CODE>T&acirc;che</CODE> courante.
     */
    
    public int getNbReadBuffer()
    {
	return readBuffers.size();
    }

    /*-------------------------------------------------------*/

    /**
       Renvoie le <CODE>indexOfBuffer</CODE>-ième 
       <CODE>Buffer</CODE> connect&eacute; en ecriture 
       sur la <CODE>T&acirc;che</CODE> courante.
     */
    
    public Buffer getWriteBuffer(int indexOfBuffer)
    {
	return (Buffer)writeBuffers.get((int)indexOfBuffer);
    }

    /*-------------------------------------------------------*/

    /**
       Renvoie le nombre de <CODE>Buffers</CODE> 
       connect&eacute;s en ecriture sur 
       la <CODE>T&acirc;che</CODE> courante.
     */
    
    public int getNbWriteBuffer()
    {
	return writeBuffers.size();
    }
    
    /*-------------------------------------------------------*/

    /**
       Renvoie au format cha&icirc;ne de caract&egrave;res le 
       script de cr&eacute;tion
       du jeu de <CODE>T&acirc;ches</CODE>, de <CODE>Buffers</CODE> 
       et les <CODE>Op&eacute;rations</CODE> 
       associ&eacute;es.
     */
    
    public static String allToString()
    {
	int nbTasks =  getNbTasks();
	String resultat = "#tasks " + nbTasks + "\n";
	resultat += Buffer.allToString() ;
	resultat += "#operations";
	    for (int i = 0 ; i < nbTasks ; i++)
		{
		    resultat += "\n" + get(i).toString() ;
		}
	return resultat;
    }

    /*-------------------------------------------------------*/

    /**
       Renvoie au format cha&icirc;ne de caract&egrave;res le script de 
       d&eacute;claration
       des <CODE>Op&eacute;rations</CODE> effectu&eacute;es par 
       cette <CODE>T&acirc;che</CODE>.
     */
    
    public String toString()
    {
	String resultat = (new Integer(this.getIndex())).toString() + "( ";
	int nbOperations = getNbOperations();
	if (nbOperations > 1)
	    {
		resultat += this.getOperation(0).toString();
	    }
	else
	    {
		resultat += ")";
		return resultat;
	    }
	for(int i = 1; i < nbOperations; i++)
	    {
		resultat = resultat + ", " + this.getOperation(i).toString();
	    }	    
	resultat += " )";
	return resultat;
    }
    
    /*-------------------------------------------------------*/

    /**
       Renvoie le nombre d'<CODE>Op&eacute;rations</CODE> 
       programm&eacute;es pour cette 
       <CODE>T&acirc;che</CODE>.
     */
    
    public int getNbOperations()
    {
	return operations.size();
    }

}