BufferPairCollection.java

package buffalo.twoTasksAnalysis;

import buffalo.dataStructures.*;

import java.util.Vector;

/**
   Ensemble d'expressions sur les dimensions de chaque 
   couple de buffers.
 */

public class BufferPairCollection
{
    private BufferPairExpression[] expressions;
    
    private Vector oneWayBuffers;
    private Vector twoWaysBuffers;

    private Task task1; 
    private Task task2; 

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

    /**
       Se crée avec les deux valeurs et 
       l'expression à laquelle on l'ajoute.
     */

    public BufferPairCollection(Task firstTask, Task secondTask)
    {
	this.task1 = firstTask; 
	this.task2 = secondTask;
	this.oneWayBuffers = initOneWayBuffers(task1, task2);
	this.twoWaysBuffers = initTwoWaysBuffers(task1, task2);
	expressions = new BufferPairExpression
	    [oneWayBuffers.size() + twoWaysBuffers.size()];
    }
    
    /*-----------------------------------------------------*/

    /**
       Retourne la <CODE>BufferPairExpression</CODE> 
       correspondant aux deux buffers pass&eacute;s en 
       param&egrave;tre.
     */

    public BufferPairExpression getBufferPairExpression
	(Buffer firstBuffer, Buffer secondBuffer)
    {
	return expressions[getHashValue(firstBuffer, secondBuffer)];
    }
    
    /*-----------------------------------------------------*/

    /**
       Retourne la valeur de hachage dans la table 
       des expressions correspondant aux deux buffers 
       pass&eacute;s en param&egrave;tre.
     */

    private int getHashValue(Buffer firstBuffer, Buffer secondBuffer)
    {
	return 
	    (firstBuffer.getIndex() * (Buffer.getNbBuffers() - 1)
	     + secondBuffer.getIndex() 
	     + k(firstBuffer, secondBuffer) );
    }
    
    /*-----------------------------------------------------*/

    /**
       Retourne la valeur de l'application <CODE>k<CODE>
       d&eacute;crite dans le rapport.
     */

    private int k(Buffer firstBuffer, Buffer secondBuffer)
    {
	if(firstBuffer.getIndex() > secondBuffer.getIndex())
	    {
		return 0;
	    }
	else
	    {
		return -1;
	    }
    }
    
    /*-----------------------------------------------------*/
    
    /**
       Ajoute <CODE>aNewBufferPairExpression</CODE> dans 
       <CODE>this</CODE>.
     */

    public void addBufferPairExpression(BufferPairExpression aNewBufferPairExpression)
    {
	Buffer firstBuffer = aNewBufferPairExpression.getFirstBuffer();
	Buffer secondBuffer = aNewBufferPairExpression.getSecondBuffer();
	int indexOfBufferPairExpression = getHashValue(firstBuffer, secondBuffer);
	expressions[indexOfBufferPairExpression] = aNewBufferPairExpression;
	aNewBufferPairExpression.setIndex(indexOfBufferPairExpression);	
    }   
    
    /*-----------------------------------------------------*/

    /**
       Retourne la <CODE>index</CODE>-i&egrave;me 
       <CODE>BufferPairExpression</CODE> 
       stock&eacute;e dans la collection courante.
     */

    public BufferPairExpression getBufferPairExpression
	(int index)
    {
	return expressions[index];
    }   

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

    /**
       Retourne le nombre de 
       <CODE>BufferPairExpression</CODE> 
       stock&eacute;es dans la collection courante.
     */

    public int getNbBufferPairExpression()
	
    {
	return expressions.length;
    }   

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

    /**
       Retourne l'instance courante au format 
       cha&icirc;ne de caract&egrave;res.
     */

    public String toString()	
    {
	String results = "\n";
	int nbExpressions = getNbBufferPairExpression();
	BufferPairExpression myBufferPairExpression;
	for(int i = 0 ; i < nbExpressions ; i++)
	    {
		myBufferPairExpression = getBufferPairExpression(i);
		if(myBufferPairExpression != null) 
		    {
			results += myBufferPairExpression.toString()+"\n";
		    }
	    }
	results += "\n";
	return results;
    }   

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

    /**
       Retourne la premi&egrave;re <CODE>t&acirc;che</CODE> 
       concern&eacute;e par cette 
       <CODE>BufferCollection</CODE>.    
     */

    public Task getFirstTask()
    {
	return task1;
    }

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

    /**
       Retourne la deuxi&egrave;me <CODE>t&acirc;che</CODE> 
       concern&eacute;e par cette 
       <CODE>BufferCollection</CODE>.
     */   

    public Task getSecondTask()
    {
	return task2;
    }

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

    /**
       Retourne les <CODE>n</CODE> couples de buffers de même direction 
       entre les buffers un et deux. Ils sont dispos&eacute;s dans 
       <CODE>2n</CODE> cases du vecteur. Le <CODE>i</CODE>-ième
       couple se trouve dans les cases <CODE>2i - 3</CODE> et 
       <CODE>2i - 2</CODE>.       
     */
    
    private static Vector initOneWayBuffers(Task task1, Task task2)
    {
	Vector results = new Vector();	
	Vector validBuffersTask1 = new Vector(); 
	Vector validBuffersTask2 = new Vector();
	Buffer myBuffer;
	int nbBuffers = task1.getNbReadBuffer();
	for(int i = 0; i < nbBuffers ; i++)
	    {
		myBuffer = task1.getReadBuffer(i);
		if (myBuffer.getWritingTask() == task2)
		    {
			validBuffersTask1.add(myBuffer);
		    }
	    }
	nbBuffers = validBuffersTask1.size();	
	for (int i = 0 ; i < nbBuffers ; i ++)
	    {
		for (int j = 0 ; j < nbBuffers ; j ++)
		    {
			if (i != j)
			    {
				results.add(validBuffersTask1.get(i));
				results.add(validBuffersTask1.get(j));
			    }
		    }
	    }
	nbBuffers = task2.getNbReadBuffer();
	for(int i = 0; i < nbBuffers ; i++)
	    {
		myBuffer = task2.getReadBuffer(i);
		if (myBuffer.getWritingTask() == task1)
		    {
			validBuffersTask2.add(myBuffer);
		    }
	    }
	nbBuffers = validBuffersTask2.size();	
	for (int i = 0 ; i < nbBuffers ; i ++)
	    {
		for (int j = 0 ; j < nbBuffers ; j ++)
		    {
			if (i != j)
			    {
				results.add(validBuffersTask2.get(i));
				results.add(validBuffersTask2.get(j));
			    }
		    }
	    }
	return results;
    }
    
    /*-------------------------------------------------------*/
    
    /**
       Retourne les <CODE>n</CODE> couples de buffers de sens 
       oppos&eacute;s entre les buffers un et deux. Ils sont dispos&eacute;s dans 
       <CODE>2n</CODE> cases du vecteur. Le <CODE>i</CODE>-ième
       couple se trouve dans les cases <CODE>2i - 3</CODE> et 
       <CODE>2i - 2</CODE>.       
     */
    
    private static Vector initTwoWaysBuffers(Task task1, Task task2)
    {
	Vector results = new Vector();	
	Vector validBuffersTask1 = new Vector(); 
	Vector validBuffersTask2 = new Vector();
	Buffer myBuffer;
	int nbBuffers = task1.getNbReadBuffer();
	int nbBuffersBis;
	for(int i = 0; i < nbBuffers ; i++)
	    {
		myBuffer = task1.getReadBuffer(i);
		if (myBuffer.getWritingTask() == task2)
		    {
			validBuffersTask1.add(myBuffer);
		    }
	    }
	nbBuffers = task2.getNbReadBuffer();
	for(int i = 0; i < nbBuffers ; i++)
	    {
		myBuffer = task2.getReadBuffer(i);
		if (myBuffer.getWritingTask() == task1)
		    {
			validBuffersTask2.add(myBuffer);
		    }
	    }
	nbBuffers = validBuffersTask1.size(); 
	nbBuffersBis =  validBuffersTask2.size(); 	
	for (int i = 0 ; i < nbBuffers ; i ++)
	    {
		for (int j = 0 ; j < nbBuffersBis ; j ++)
		    {
			results.add(validBuffersTask1.get(i));
			results.add(validBuffersTask2.get(j));
			results.add(validBuffersTask2.get(j));
			results.add(validBuffersTask1.get(i));
		    }
	    }
	return results;
    }

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

    /**
       Retourne les <CODE>n</CODE> couples de buffers de même direction 
       entre les buffers un et deux. Ils sont dispos&eacute;s dans 
       <CODE>2n</CODE> cases du vecteur. Le <CODE>i</CODE>-ième
       couple se trouve dans les cases <CODE>2i - 3</CODE> et 
       <CODE>2i - 2</CODE>.       
     */
    
    public Vector getOneWayBuffers()
    {
	return oneWayBuffers;
    }
    
    /*-------------------------------------------------------*/
    
    /**
       Retourne les <CODE>n</CODE> couples de buffers de sens 
       oppos&eacute;s entre les buffers un et deux. Ils sont dispos&eacute;s dans 
       <CODE>2n</CODE> cases du vecteur. Le <CODE>i</CODE>-ième
       couple se trouve dans les cases <CODE>2i - 3</CODE> et 
       <CODE>2i - 2</CODE>.       
     */
    
    public Vector getTwoWaysBuffers()
    {
	return twoWaysBuffers;
    }
}