BufferDomain.java

package buffalo.twoTasksAnalysis;

import java.util.Vector;
import buffalo.dataStructures.*;
import buffalo.util.Heap;


/**
   Représente à la fois le domaine de définition des 
   capacités pertinentes d'un buffer et un 
   sous-ensemble de sommets d'un graphe.   
 */

public class BufferDomain
{
    private BufferBipartiteGraph myGraph;
    private Buffer myBuffer;
    private Vector myBufferValues;
    private Heap myHeap;
    private int maximin;


    /*---------------------------------------------*/
    
    /**
       S'instancie avec le <CODE>myBuffer</CODE>
       dont l'instance courante est le domaine.
    */
    
    public BufferDomain(BufferBipartiteGraph myGraph, Buffer myBuffer)
    {
	this.myBuffer = myBuffer;
	this.myBufferValues = new Vector();
	this.myGraph = myGraph;
	maximin = 1;
	myHeap = new Heap();
	myGraph.addBufferDomain(this);
    }
    
    /*---------------------------------------------*/
    
    /**
       Retourne le <CODE>buffer</CODE>
       dont l'instance courante est le domaine.
    */
    
    public Buffer getBuffer()
    {
	return myBuffer;
    }

    /*---------------------------------------------*/
    
    /**
       Renvoie <CODE>k(myBuffer)</CODE>, autrement dit 
       le nombre de valeurs pertinentes pour 
       le <CODE>buffer</CODE>
       dont l'instance courante est le domaine.       
     */

    public int getNbBufferValues()
    {
	return myBufferValues.size();
    }
    
    /*---------------------------------------------*/
    
    /**
       Renvoie la <CODE>index</CODE>-i&egrave;me
       valeur pertinente pouvant être 
       prise par le <CODE>buffer</CODE>
       dont l'instance courante est le domaine.
     */

    public BufferValue getBufferValue(int index)
    {
	return (BufferValue)myBufferValues.get(index);
    }    

    /*---------------------------------------------*/
    
    /**
       Ajoute une valeur pour ce buffer.
     */

    public void addBufferValue(int value)
    {
	myBufferValues.add
	    (new BufferValue(this, value));
    }   

    /*---------------------------------------------*/
    
    /**
       Met &agrave; jour le maximin pour ce buffer avec 
       la valeur pass&eacute;e en param&egrave;tre.
     */

    public void updateMaximin(int newValue)
    {
	if (maximin < newValue)
	    {
		maximin = newValue;
	    }
    }   

    /*---------------------------------------------*/
    
    /**
       Vide le tas et place les valeurs pertinentes 
       dans les sommets du graphe biparti.
     */

    public void load()
    {
	Integer myValue = (Integer)myHeap.getRoot();
	this.addBufferValue(maximin);
	while((myValue != null)&&(myValue.intValue()<=maximin))
	    {
		myHeap.removeRoot();
		myValue = (Integer)myHeap.getRoot();
	    }
	while(myValue != null)
	    {
		this.addBufferValue(myValue.intValue());
		myHeap.removeRoot();
		myValue = (Integer)myHeap.getRoot();
	    }
	defineWeights();
    }
    
    /*---------------------------------------------*/
    
    /**
       Retourne l'indice de ce domaine.
     */

    public int getIndex()	
    {
	return myBuffer.getIndex();
    } 

    /*---------------------------------------------*/
    
    /**
       Retourne le tas servant 
       &agrave; trier les valeurs pour ce buffer.
     */

    public Heap getHeap()
    {
	return myHeap;
    } 

    /*---------------------------------------------*/
    
    /**
       D&eacute;finit tous les poids.
     */

    public void defineWeights()
    {
	int nbValues = myBufferValues.size();
	for (int i = 0 ; i < nbValues; i++)
	    {
		((BufferValue)myBufferValues.get(i)).defineWeight();
	    }
    } 

    /*---------------------------------------------*/
    
    /**
       Retourne ce domaine au format cha&icirc;ne de 
       caract&egrave;res.
     */

    public String toString()
    {
	String result = "Domain of Buffer ";
	result += myBuffer.getIndex() + " = ";
	int nbValues = myBufferValues.size();	
	result += ((BufferValue)myBufferValues.get(0)).toString();
	for (int i = 1 ; i < nbValues; i++)
	    {
		result += ", " + ((BufferValue)myBufferValues.get(i)).toString();
	    }
	result += ";\n";
	return result;
    }
    
    /*---------------------------------------------*/
    
    /**
       Retourne le graphe biparti dont ce domaine 
       fait partie.
    */
    
    public BufferBipartiteGraph getBufferBipartiteGraph()
    {
	return myGraph;
    }

    /*---------------------------------------------*/
    
    /**
       Retourne le <CODE>BufferValue</CODE>
       ayant pour <CODE>value</CODE>
       le param&egrave;tre <CODE>valueForBuffer</CODE>, 
       retourne <CODE>null</CODE> si une telle 
       valeur n'existe pas.
    */
    
    public BufferValue findBufferValue(int valueForBuffer)
    {
	int nbBufferValues = getNbBufferValues();
	if ((nbBufferValues < 2)||(valueForBuffer<getBufferValue(1).getValue()))
	    {
		return null;
	    }
	else
	    {
		return findBufferValue(valueForBuffer, 0, nbBufferValues-1);
	    }
	
    }

    /*---------------------------------------------*/
    
    /**
       Recherche par dichotomie le <CODE>BufferValue</CODE>
       ayant pour <CODE>value</CODE>
       le param&egrave;tre <CODE>valueForBuffer</CODE>.
    */
    
    private BufferValue findBufferValue(int valueForBuffer, 
					int lowerBound, 
					int upperBound)
    {
	int myIndex = (int)(((float)lowerBound + (float)upperBound)/2.);
	BufferValue myBufferValue = getBufferValue(myIndex);
	int myValue = myBufferValue.getValue();
 	if (myValue == valueForBuffer)
	    {
		return myBufferValue;
	    }
	else
	    {
		if (myValue<valueForBuffer)
		    {
			return findBufferValue(valueForBuffer, myIndex+1, upperBound);
		    }
		else
		    {
			return findBufferValue(valueForBuffer, lowerBound, myIndex-1);
		    }
	    }	
    }    
    
}