// Il faut explicer cette référence pour JavaDoc 1.3
import java.lang.Object;

/** Définition des bits.
 ** 
 ** <P> Un bit est clonable (on peut en faire une copie directe). 
 ** </P>
 **
 ** @author Alexis Scheuer
 ** @version 11 2003
 **/
public class Bit implements Cloneable {
    // === Champs de la classe ====================================

    private boolean val;  // valeur du bit (true -> 1, false -> 0)


    // === Constructeur ===========================================

    /** Crée un bit à partir d'un booléen (true -> 1, false -> 0).
     **
     ** @param egalUn  indique si le bit est égal à un. 
     **/
    public Bit(boolean egalUn)  { met(egalUn); } 


    // === Méthodes de description ================================

    /** Indique si le bit courant est égal à un. 
     **
     ** @return si le bit courant est égal à un.
     **/ 
    public boolean vautUn()  { return val; } 

    /** Indique si le bit courant est égal à zéro. 
     **
     ** @return si le bit courant est égal à zéro.
     **
     ** @see #vautUn
     **/ 
    public boolean vautZero()  { return( !vautUn() ); } 


    /** Indique si deux bits sont égaux.
     **
     ** On utilise ici un nom de méthode anglais, pour surcharger 
     ** la méthode standard de la classe {@link Object}. 
     **
     ** @param  autre  le bit à comparer au bit courant. 
     **
     ** @return si le bit courant est égal au bit donné.
     **/
    public boolean egal(Bit autre)  { return(val == autre.val); }

    /** Indique si ce bit est égal à un objet. 
     **
     ** On utilise ici un nom de méthode anglais, pour surcharger 
     ** la méthode standard de la classe {@link Object}. 
     **
     ** @param  autre  l'objet à comparer au bit courant. 
     **
     ** @return <TT>true</TT> si l'objet donné est un bit égal 
     **         au bit courant, <TT>false</TT> sinon.
     **
     ** @see    #getClass
     ** @see    #egal
     **/
    public boolean equals(Object autre)  { 
	return( getClass().equals( autre.getClass() ) && 
		egal( (Bit) autre ) ); }


    /** Écrit le bit courant sous la forme d'un caractère 
     ** ('0' ou '1'). 
     **
     ** @return le bit courant sous la forme '0' ou '1'. 
     **/ 
    public char ecrit()  { return(vautUn() ? '1' : '0'); } 


    // === Méthodes de modification ===============================

    /** Change le bit courant. 
     **
     ** @param  aUn  indique si le bit doit être mis à un. 
     **
     ** @see #vautUn
     **/
    public void met(boolean aUn)  { val = aUn; } 


    /** Copie un bit donné dans le bit courant.
     **
     ** @param  autre le bit à copier dans le bit courant.
     **/
    public void copie(Bit autre)  { met( autre.vautUn() ); } 


    /** Inverse un bit (0 <-> 1). */
    public void inverse()  { met( vautZero() ); } 


    // === Opération arithmétique =================================

    /** Additionne un bit au bit courant, en tenant compte 
     ** d'une retenue (qui peut être modifiée par l'addition). 
     **
     ** @param  ajout    le bit à ajouter au bit courant, 
     ** @param  retenue  la retenue (qui peut changer). 
     **/ 
    public void ajoute(Bit ajout, Bit retenue) { 
	if ( egal(ajout) ) {  // 0 + 0 ou 1 + 1 
	    // le bit prend la valeur de la retenue
	    copie(retenue); 
	    // la retenue prend la valeur de l'ajout
	    retenue.copie(ajout); } 
	else                     // 0 + 1 ou 1 + 0
	    // le bit prend l'inverse de la valeur de 
	    // la retenue (qui ne change pas)
	    met( retenue.vautZero() ); 
    } 

} // fin de la classe