GENERATEUR DE MOT PAR INCREMENTATION

/***************************************************************************************************************
 *    ElgStringIterator - v1.1
 *  -----------------------------------------------------------------------------------------------------
 *    Generation de chaine par permutation lineaire depuis une liste de caractere
 *
 *    Ecrit par LEVEUGLE Damien
 *    Elguevel software (c) 2009
 *    http://elguevel.free.fr/
 *
 *  -----------------------------------------------------------------------------------------------------
 *    v1.0 : release
 *    v1.1 : Modification des termes utilisés
 *           Modification du main
 */
class ElgStringIterator
{

    /******************************************************************************************************************
     *  Constructeur                                                                                                  *
     ******************************************************************************************************************/

    // Constructeur par defaut
    public ElgStringIterator() throws Exception
    {
        // Par defaut on se sert de tous les caractères
        // Ps : Cette liste peut être personnalisée via "setCaracteres()"
        _caracteres = this.EGL_SI_CHAR_MINUSCULE +
                      this.EGL_SI_CHAR_MAJUSCULE +
                      this.EGL_SI_CHAR_NUMERIQUE +
                      this.EGL_SI_CHAR_SPECIAUX;
    }


    /******************************************************************************************************************
     *  Constantes                                                                                                    *
     ******************************************************************************************************************/

    // Listes de caractères prédefinies

    public static final String EGL_SI_CHAR_MINUSCULE = "abcdefghijklmnopqrstuvwxyz";
    public static final String EGL_SI_CHAR_MAJUSCULE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    public static final String EGL_SI_CHAR_NUMERIQUE = "0123456789";
    public static final String EGL_SI_CHAR_SPECIAUX  = "!$%&/()=?";


    /******************************************************************************************************************
     *  Attributs                                                                                                     *
     ******************************************************************************************************************/

    private String _caracteres;         // Caractères utilisés pour la generation de la chaine


    /******************************************************************************************************************
     *  Proprietes                                                                                                    *
     ******************************************************************************************************************/

    // Accesseur sur _caracteres
    public String getCaracteres()
    {
        return _caracteres;
    }

    // Mutateur sur _caracteres
    public void setCaracteres( String valeur )
    {
        _caracteres = valeur;
    }


    /******************************************************************************************************************
     *  Methodes                                                                                                      *
     ******************************************************************************************************************/

    // Cherche dans la liste "_caracteres" le caractere demande, et renvoi le suivant
    // Nb : S'il s'agit du dernier caractere on repasse en debut de liste
    private char prochainCaractere(char caractere) throws Exception
    {
        char resultat;

        char premierCaractere = this._caracteres.charAt(0);
        char dernierCaractere = this._caracteres.charAt(this._caracteres.length() - 1);

        int position = this._caracteres.indexOf(caractere);

        if (caractere == dernierCaractere)
            resultat = premierCaractere;
        else
            resultat = this._caracteres.charAt( position + 1 );

        return resultat;
    }

    // Genere chaine suivante
    public String chaineSuivante(String chaineOrigine) throws Exception
    {
        String chaineNouvelle = "";               // Resultat (nouvelle chaine generee)

        int iterateur;                            // Iterator
        int increment;                            // Memorise position dans la chaine
        int pointeurPosition;                     // Memorise position dans la chaine

        char premierCaractere = this._caracteres.charAt(0);                                    // Premier caractere de la liste de caracteres
        char dernierCaractere = this._caracteres.charAt(this._caracteres.length() - 1);        // Dernier caractere de la liste de caracteres

        if ( chaineOrigine.trim().equals("") ) return new String("") + premierCaractere;

        pointeurPosition = chaineOrigine.length();
        increment = 0;

        // Calcul positions
        while (pointeurPosition > 0)
        {
            if (chaineOrigine.charAt(pointeurPosition - 1) != dernierCaractere)
            {
                increment = pointeurPosition - 1;
                break;
            }

            pointeurPosition--;

            if (pointeurPosition == 0)
            {
                pointeurPosition--;
                break;
            }
        }

        // Generation mot de passe
        if (pointeurPosition < 0)
        {
            for (iterateur = 0; iterateur < (chaineOrigine.length() + 1); iterateur++)
                chaineNouvelle = chaineNouvelle + premierCaractere;
        }
        else
        {
            if (increment == 0)
                chaineNouvelle = new String("") + this.prochainCaractere(chaineOrigine.charAt(increment) );
            else
                chaineNouvelle = chaineOrigine.substring(0, increment) + this.prochainCaractere(chaineOrigine.charAt(increment));

            for (iterateur = increment + 1; iterateur < (chaineOrigine.length()); iterateur++)
                chaineNouvelle = chaineNouvelle + premierCaractere;
        }

        return chaineNouvelle;
    }


    /******************************************************************************************************************
     *  Entry point (Test)                                                                                            *
     ******************************************************************************************************************/

    public static void main( String[] args )
    {
        String maChaine = "";
        int    niveauProfondeur = 0;

        System.out.println("\n----------------------------------------------------------");
        System.out.println(" ElgStringIterator - Generateur de chaine par permutation");
        System.out.println(" Ecrit par LEVEUGLE Damien");
        System.out.println(" Elguevel software (c) 2009");
        System.out.println("----------------------------------------------------------\n");

        try
        {

            ElgStringIterator monObjet = new ElgStringIterator();

            // Trop d'arguments
            if ( args.length < 3 )
            {

                // Si au moins 1 ou 2 arguments
                if ( args.length > 0 )
                {
                    // Recupere niveau profondeur (sinon infini)
                    try
                    {
                        niveauProfondeur = (int) Integer.valueOf( args[0] );
                    }
                    catch ( NumberFormatException nfe )
                    {
                        System.out.println("\tErreur : Niveau de profondeur invalide !\n");
                        System.exit(1);
                    }

                    // Recupere chaine de depart
                    if ( args.length > 1 ) maChaine = args[1];
                }

                // Affichage chaines
                while ( niveauProfondeur == 0 || niveauProfondeur >= maChaine.length() )
                {
                    maChaine = monObjet.chaineSuivante( maChaine ); // Recupere chaine, et renvoi la suivante
                    System.out.println( "-> " + maChaine );
                }

            }
            else
            {
                System.out.println("\tUsage : ElgStringIterator <longueure max.> <chaine de depart>\n" );
            }

        }
        catch( Exception ex )
        {
            System.out.println("Erreur : " + ex.toString() );
        }

    }

}