Arc.java

package buffalo.transportNetwork;

/**
   Exemple d'implémentation de l'interface 
   <CODE>FlowableArc</CODE>, repr&eacute;sente une ar&ecirc;te 
   du r&eacute;seau de transport.
*/

public class Arc implements FlowableArc
{

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

    /**
       Capacit&eacute; minimale de l'arc, 
       ie. borne inf&eacute;rieure pour le flot.
     */

    private double minCapacity;

    /**
       Capacit&eacute; maximale de l'arc, 
       ie. borne sup&eacute;rieure pour le flot.
     */

    private double maxCapacity;

    /**
       Valeur du flot circulant dans l'arc...
     */

    private double flowValue;
    
    /**
       Sommet dont l'ar&ecirc;te courante "part".
     */

    private Vertex inVertex;
    
    /**
       Sommet dans lequel l'ar&ecirc;te courante "arrive".
     */

    private Vertex outVertex;

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

    /**
       Une ar&ecirc;te se construit &agrave; partir de 
       deux sommets, une borne inf&eacute;rieure et 
       une borne sup&eacute;rieure. Ce constructeur 
       se charge aussi d'invoquer les 
       <CODE>add**Arc(this)</CODE>.
    */    

    public Arc(Vertex inVertex, Vertex outVertex, 
		double minCapacity, double maxCapacity)
    {	
	this.inVertex=inVertex;
	this.outVertex=outVertex;
	this.minCapacity=minCapacity;
	this.maxCapacity=maxCapacity;
	this.inVertex.addOutArc(this);
	this.outVertex.addInArc(this);
    }

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

    /**
       Retourne la borne inf&eacute;rieure de la 
       capacit&eacute; de l'arc.
     */    

    public double getMinCapacity()
    {
	return minCapacity;
    }

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

    /**
	Retourne la borne sup&eacute;rieure de la 
	capacit&eacute; de l'arc.   
    */

    public double getMaxCapacity()
    {
	return maxCapacity;
    }

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

    /**
       Retourne la valeur du flot.
    */

    public double getFlowValue()
    {
	return flowValue;
    }

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

    /**
       Pour augmenter le flot dans le sens conforme.
     */
    
    public void increaseConformFlow(double increment)
    {
	flowValue += increment;
    }
    
    /*-------------------------------------------------*/

    /**
       Pour augmenter le flot dans le sens non conforme.
     */
    
    public void increaseUnconformFlow(double increment)
    {
	flowValue =  flowValue - increment;
    }
    
    /*-------------------------------------------------*/

    /**
       Retourne la valeur r&eacute;siduelle de l'arc 
       (si il est pris dans le sens conforme).
    */

    public double getConformResidualValue()
    {
	if (maxCapacity != -1)
	    {		
		return (maxCapacity - flowValue);
	    }
	else
	    {
		return -1;
	    }
    }

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

    /**
       Retourne la valeur r&eacute;siduelle de l'arc 
       (si il est pris dans le sens non conforme).
    */

    public double getUnconformResidualValue()
    {
	if(minCapacity != -1)
	    {		
		return (flowValue - minCapacity);
	    }
	else
	    {
		return -1;
	    }
    }

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

    /**
       Retourne le sommet de "d&eacute;part" de l'arc.
    */

    public FlowableVertex getInVertex()
    {
	return inVertex;
    }

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

    /**
       Retourne le sommet d'"arriv&eacute;e" de l'arc.
    */

    public FlowableVertex getOutVertex()
    {
	return outVertex;
    }
    /*-------------------------------------------------*/

    /**
       Retourne l'ar&ecirc;te au format 
       cha&icirc;ne de caract&egrave;res
    */

    public String toString()
    {
	String res = "{ min = ";
	if (minCapacity > 0)
	    {
		res += " unbound ";
	    }
	else
	    {
		res += minCapacity;
	    }   
	res += " max = ";
	if (maxCapacity < 0)
	    {
		res += " unbound ";
	    }
	else
	    {
		res += maxCapacity;
	    }   
	res += " flowValue = " + flowValue;
	res += " outVertex = " + outVertex.getIndex();
	res += " } ";
	return res;
    }
}