Utilisation des Regex avec Qt

Comment tester la validité d'une adresse mail ? Notez que cet exemple n'est pas adapté à un contexte réel et n'est là que pour illustrer de manière théorique l'utilisation des Regex.

Une adresse mail doit être de la forme : utilisateur@fai.truc. Voici la Regex :

^[\w|\.]+@[\w]+\.[\w]{2,4}$

Cela peut certes sembler assez incompréhensible, mais il faut prendre le temps de bien décomposer les étapes.

^[\w|\.]+

Déjà ici on analyse la première partie de l'adresse, celle-ci peut être composée de n'importe quel caractère (\w) ou d'un point (\w n'inclut pas le point), le tout répété au moins une fois.

@[\w]+

Ici on précise qu'il doit y avoir un @ suivi de n'importe quel caractère alphabétique (\w) répété au moins une fois.

\.[\w]{2, 4}

Dans cette dernière partie, on précise qu'il doit y avoir un caractère "." (le point est échappé, pour ne pas signifier n'importe quel caractère), suivi de deux à quatre caractères alphabétiques (ce qui couvre .fr, .com, .gouv, etc.).

• nom@fai.com
• agent.secret@truc.gouv
• b@c.fr
• etc...

• nom.nom@fai.truci
• @fai.com
• machin.truc.com

Comment tester la validité d'une adresse IP ? Notez que cet exemple n'est pas adapté à un contexte réel et n'est là que pour illustrer de manière théorique l'utilisation des Regex.

Une adresse IP doit être de la forme xxx.xxx.xxx.xxx, voici une Regex possible :

^[\d]{2,3}\.[\d]{2,3}\.[\d]{2,3}\.[\d]{2,3}$

Cette Regex est déjà plus simple.

^[\d]{2, 3}\.

Première partie, le ^ utilisé pour signaler le début de la chaîne puis un bloc (qui sera répété) qui spécifie qu'il doit y avoir une suite de deux ou trois chiffres quelconques, le tout doit être suivi d'un point.
Ce bloc est répété (sauf pour le point) pour le reste de l'adresse IP, étant donné qu'elle est composée de blocs de deux ou trois chiffres.
Et enfin, la Regex est terminée par le symbole $, pour qu'aucun autre caractère après ne soit accepté.

Comment tester la validité d'une adresse Internet ? Notez que cet exemple n'est pas adapté à un contexte réel et n'est là que pour illustrer de manière théorique l'utilisation des Regex.

Une adresse Internet doit être de la forme www.xxx.xxxx. Voici une des Regex possibles :

^[w]{3}\.[\w]+\.[\w]{2,4}$

Ici nous avons :

^[w]{3}

qui signal trois w,

\.[\w]+\.

suivis d'un point puis de n'importe quel caractère répété au moins une fois et d'un autre point,

[\w]{2,4}$

suivis d'une extension (.fr, .com, .gouv) d'au moins deux caractères et au maximum de quatre caractères.

Cette fonction dont voici le prototype :

bool QRegExp::isValid () const

renvoie false si la Regex donnée en argument n'est pas valide (une Regex non valide n'accepte aucune chaîne de caractères), true sinon.

Cette fonction :

QString QRegExp::errorString ()

retourne un texte explicatif d'une éventuelle erreur qui a pu se produire. S'il n'y a pas d'erreur, la fonction retourne "no error occurred".

La fonction :

bool QRegExp::exactMatch (const QString & str) const

renvoie true si la chaîne de caractères passée en argument est exactement équivalente à la Regex, par exemple, pour la Regex "a", la fonction renvoie true uniquement si la chaîne de caractères correspond à "a" exactement, elle renvoie false pour "aa", "ab", etc. Cela revient à rajouter "^" en début de Regex et "$" en fin de Regex.

La fonction indexIn dont voici le prototype :

int QRegExp::indexIn (const QString & str, int offset = 0, CaretMode caretMode = CaretAtZero) const

cherche à valider une partie de str à partir de la position offset. Renvoie la position.

La fonction

int QRegExp::lastIndexIn (const QString & str, int offset = -1, CaretMode caretMode = CaretAtZero) const

ressemble beaucoup à la fonction indexIn à ceci près qu'elle effectue la recherche dans l'autre sens, en partant de la position offset qui par défaut vaut -1 (dernier caractère de la chaîne). Cette fonction renvoie la position de la première occurrence trouvée.

Attention, rechercher à l'envers est plus lent que rechercher à l'endroit, ainsi si vous avez le choix, préférez la recherche à l'endroit.

Cette fonction :

int QRegExp::matchedLength () const

renvoie la taille de la chaîne capturée, -1 si aucune chaîne n'a été trouvée.

Cette fonction dont voici le prototype :

int QRegExp::numCaptures () const

retourne le nombre d'expressions capturées.

Pour ne pas alourdir le tutoriel en codage de GUI, je vous propose d'utiliser le QtDesigner pour créer notre interface graphique (mais rien ne vous empêche de la coder à la main si vous n'êtes pas à l'aise avec le Designer), celle-ci sera relativement simple :

• deux labels d'information pour indiquer a l'utilisateur où entrer sa commande et où apparaît le code C++ généré, des QLabel ;
• une entrée de texte où l'utilisateur pourra entrer sa commande, nous utiliserons un QLineEdit ;
• une case à cocher si l'utilisateur souhaite que le programme génère également les includes nécessaires à la correcte compilation du code donnév
• un sortie de texte où l'utilisateur pourra récupérer le code C++ généré, un QTextEdit ;
• une barre de menus, permettant de lancer la génération du code et d'afficher une fenêtre d'aide.

À l'aide du QtDesigner, l'interface est vite prête, vous devriez obtenir quelque chose comme cela :

En rouge vous pouvez voir un gestionnaire de disposition horizontale qui sert à contenir le label et l'entrée de texte pour que l'utilisateur puisse saisir sa commande, et en bleu vous pouvez voir le layout principal qui est un gestionnaire de disposition vertical. Pour la bonne suite de la construction du projet, il est nécessaire de donner des noms intuitifs aux widgets de notre fenêtre, voici la liste de ceux que j'ai donnés à mes widgets, rien ne vous empêche d'en utiliser d'autres mais il vous faudra alors adapter le code :

• l'entrée de texte où l'utilisateur saisit sa commande s'appelle commandEntry ;
• le bouton de validation s'appelle confirmButton ;
• la case à cocher d'option s'appelle includeCheckBox ;
• la zone de texte éditable où apparaîtra le code généré s'appelle textEdit ;
• l'action pour valider la commande s'appelle actionStartCommand, celle pour l'aide actionHelp et celle pour le à propos actionAboutQt ;
• les noms des autres contrôles n'ont qu'une importance mineure étant donné que nous n'aurons pas besoin de les utiliser dans le code que nous écrirons.

Là encore je vais essayer de faire dans la simplicité, notre projet se composera donc de quatre fichiers :

1. main.cpp, fichier "principal" du programme ;
2. mainwindow.h, fichier contenant la déclaration de la classe mainWindow ;
3. mainwindow.cpp, fichier contenant l'implémentation de la classe mainWindow ;
4. mainwindow.ui, fichier généré par le Designer contenant l'interface graphique de notre programme.

À partir de ce point je suppose que vous avez au préalable correctement créé l'interface du programme à l'aide du designer. Je vous propose de commencer par coder la déclaration de notre classe MainWindow, ici rien de bien compliqué :

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

class QWidget ;
class QString ;

namespace Ui
{
    class MainWindowClass ;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public :
    MainWindow (QWidget *parent = 0) ;
    ~MainWindow () ;
    bool isValidCommand () ;
    void toGenerateCode () ;
    bool toParseCommand () ;
    bool toParseFileCommand () ;
    bool toParseStringCommand () ;

public slots :
    void onEnterCommand () ;
    void Help () ;

private :
    Ui::MainWindowClass *ui ;
    QString code ;
};

#endif // MAINWINDOW_H

Vous noterez l'utilisation de l'interface graphique créée par le Designer qui, je suppose, est générée dans le fichier ui_mainwindow.h.

Commençons en douceur par les includes en anticipant sur les classes dont nous allons nous servir :

	/* Inclusion des classes Qt */
#include <QRegExp>
#include <QMessageBox>
#include <QWidget>
#include <QMainWindow>

	/* Inclusion de nos fichiers */
#include "mainwindow.h"
#include "ui_mainwindow.h"

Passons au constructeur de notre classe MainWindow, là non plus rien de bien compliqué, on génère l'interface graphique à l'aide de la fonction automatiquement codée par le Designer puis on connecte les signaux de nos trois actions et du bouton pour valider la commande :

MainWindow::MainWindow (QWidget *parent)
    : QMainWindow (parent), ui (new Ui::MainWindowClass)
{
        /* Construction de l'interface graphique */
    ui->setupUi(this) ;

        /* Connexion des signaux */
    connect (ui->confirmButton, SIGNAL (clicked ()), this, SLOT (onEnterCommand ())) ;
    connect (ui->actionStartCommand, SIGNAL (triggered ()), this, SLOT (onEnterCommand())) ;
    connect (ui->actionAboutQt, SIGNAL (triggered ()), qApp, SLOT (aboutQt())) ;
    connect (ui->actionHelp, SIGNAL (triggered ()), this, SLOT (Help ())) ;

        /* Mise en forme du texte sous forme de code */
    code = "<code>" ;
}

Codons à présent le slot qui sera appelé lorsque l'utilisateur cliquera sur le bouton, on vérifie si la commande est valide puis on appelle la fonction toGenerateCode () :

void MainWindow::onEnterCommand ()
{
    if (isValidCommand ())
        toGenerateCode () ;
    else
        return ;
}

La fonction isValidCommand :

bool MainWindow::isValidCommand ()
{
    if (ui->commandEntry->text () == "")
    {
        QMessageBox::critical (this, "Erreur", "Aucune commande n'a été entrée") ;
        return false ;
    }
    else
    {
        return toParseCommand () ;
    }
    return true ;
}

Ici c'est encore simple, il suffit de vérifier si l'utilisateur a entré une commande puis d'appeler la fonction toParseCommand (), qui regarde si la commande est de type FILE_xxx ou STRING_xxx, si la commande ne correspond à aucune de ces deux possibilités, on affiche un message d'erreur et on retourne false :

bool MainWindow::toParseCommand ()
{
    QRegExp FILECommand ("FILE_.+") ;
    QRegExp STRINGCommand ("STRING_.+") ;
    if (ui->commandEntry->text ().contains (FILECommand))
    {
        return toParseFileCommand () ;
    }
    else if (ui->commandEntry->text ().contains (STRINGCommand))
    {
        return toParseStringCommand () ;
    }
    else
    {
        QMessageBox::critical (this, "Erreur", "Commande invalide") ;
        return false ;
    }
}

Je vais coder avec vous la fonction toParseFileCommand, puis la fonction toParseMathCommand et je vous laisserais coder toParseStringCommand, commençons par établir une liste précise des commandes acceptées.

• FILE_create:nom_du_fichier, pour créer un nouveau fichier, nous utiliserons la Regex FILE_create:(.+).
• FILE_write:nom_du_fichier:texte_à_écrire, pour écrire du texte dans un fichier, nous utiliserons la Regex FILE_write:(.+):(.+).
• FILE_append:nom_du_fichier:texte_a_ajouter, pour ajouter du texte à la fin d'un fichier, nous utiliserons la Regex FILE_append:(.+):(.+).
• FILE_rename:ancien_nom:nouveau_nom, pour renommer un fichier, nous utiliserons la Regex FILE_rename:(.+):(.+).

bool MainWindow::toParseFileCommand ()
{
    QRegExp FILECreateCommand ("FILE_create:(.+)") ;
    QRegExp FILEWriteCommand ("FILE_write:(.+):(.+)") ;
    QRegExp FILEAppendCommand ("FILE_append:(.+):(.+)") ;
    QRegExp FILERenameCommand ("FILE_rename:(.+):(.+)") ;
    if (ui->commandEntry->text ().contains (FILECreateCommand))
    {
        QString filename = FILECreateCommand.cap (1) ;
        filename.replace ("\\", "\\\\") ;
        if (ui->includeCheckBox->isChecked ())
        {
            code += "#include &lt;iostream&gt;<br>#include &lt;fstream&gt;<br><br>" ;
        }
        code += "ofstream outStream (\"" + filename + "\", ios::out) ;" ;
        return true ;
    }
    else if (ui->commandEntry->text ().contains (FILEWriteCommand))
    {
        QString filename = FILEWriteCommand.cap (1) ;
        filename.replace ("\\", "\\\\") ;
        if (ui->includeCheckBox->isChecked ())
        {
            code += "#include &lt;iostream&gt;<br>#include &lt;fstream&gt;<br><br>" ;
        }
        code += "ofstream outStream (\"" + filename + "\", ios::out) ;<br>outStream &lt;&lt;\"" + FILEWriteCommand.cap (2) + "\" ;" ;
        return true ;
    }
    else if (ui->commandEntry->text ().contains (FILEAppendCommand))
    {
        QString filename = FILEAppendCommand.cap (1) ;
        filename.replace ("\\", "\\\\") ;
        if (ui->includeCheckBox->isChecked ())
        {
            code += "#include &lt;iostream&gt;<br>#include &lt;fstream&gt;<br><br>" ;
        }
        code += "ofstream outStream (\"" + filename + "\", ios::out | ios::app) ;<br>outStream &lt;&lt;\"" + FILEAppendCommand.cap (2) + "\" ;" ;
        return true ;
    }
    else if (ui->commandEntry->text ().contains (FILERenameCommand))
    {
        QString filename = FILERenameCommand.cap (1) ;
        filename.replace ("\\", "\\\\") ;
        QString filename_new = FILERenameCommand.cap (2) ;
        filename_new.replace ("\\", "\\\\") ;
        if (ui->includeCheckBox->isChecked ())
        {
            code += "#include &lt;cstdio&gt;<br><br>" ;
        }
        code += "if (rename (\"" + filename + "\", \"" + filename_new + "\") == -1) <br>{<br>\tcerr &lt;&lt; \"Erreur lors du changement de nom du fichier \" ;<br>}" ;
        return true ;
    }
    else
    {
        QMessageBox::critical (this, "Erreur", "Commande FILE_xxx invalide") ;
        return false ;
    }
    return false ;
}

Comme promis je vous laisse faire pour toParseString (), à présent codons le slot Help :

void MainWindow::Help ()
{
    QMessageBox::about
(this, "Aide", "Le programme CPPGenerator est un utilitaire d'aide à la conception de programme C++, il reconnait 2 commandes :"
               "<br>FILE_create:nom_du_fichier pour créer un nouveau fichier"
               "<br>FILE_write:nom_du_fichier:text_a_écrire pour écrire du texte dans un fichier."
               "<br>FILE_append:nom_du_fichier:text_a_ajouter pour ajouter du texte à la fin d'un fichier."
               "<br>FILE_rename:ancien_nom:nouveau_nom pour renommer un fichier.") ;
}

C'est sûrement la fonction la plus simple car elle se contente d'afficher une boîte d'informations avec les différentes commandes supportées. Ici, je n'ai mis que celle que je vous ai donnée, je vous laisse modifier le texte pour ajouter les vôtres.

La fonction toGenerateCode, elle aussi est relativement simple, maintenant que tout le travail est fait :

void MainWindow::toGenerateCode ()
{
    code += "</code>" ;
    ui->textEdit->append ("<u>Code généré pour la commande <b>" + ui->commandEntry->text () + "</b> :</u><br>" + code + "<br>") ;
    code = "<code>" ;
    ui->commandEntry->setText ("") ;
}

Le destructeur à présent, car il ne faut pas oublier de libérer la mémoire utilisée par l'interface :

MainWindow::~MainWindow ()
{
    delete ui ;
}

Là encore, il n'y a rien à coder (ou presque) :

#include <QApplication>
#include "mainwindow.h"

int main (int argc, char *argv[])
{
    QApplication app (argc, argv) ;
    MainWindow w ;
    w.show () ;
    return app.exec () ;
}