Discussion :

[kidpaddle2]

Bonjour,

Je m'intéresse particulièrement ces temps-ci à cette merveilleuse (vraiment) bibliothèque que constitue Boost. Etant en pleine conception d'un lecteur audio, j'aimerais utiliser la classe 'path' de Boost.FileSystem pour vérifier qu'un certain chemin -absolu-, de type std::string, identifie un fichier musical (WMA, WAV, MP3, OGG...). Pour cela, j'ai cru comprendre que cette classe permettait d'utiliser une fonction perso comme name checker (retournant 'true' si le chemin est correct), et j'ai donc pensé en utiliser une pour cela.

Voilà le topo : comment fonctionne la vérification ? Est-elle effectuée à la construction de l'objet (si c'est le cas, l'objet est-il vide si le test échoue ?) ? Durant l'utilisation d'itérateurs ?

Merci d'avance.

P.S: Un code serait le bienvenu, si c'est possible

[H.S] Pendant que j'y suis, connaîtriez-vous une manière -en utilisant Boost.Random- de générer des entiers naturels pseudo-aléatoires (une idée du générateur approprié etc.) ? Merci.

[poukill]

Pour tester un chemin, utilise la fonction exists:
Un exemple rapide :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
std::string chaine = "C:/test/hop.txt";
if ( boost::filesystem::exists(chaine) )
{
	DVCAMIR_NFS_LUT_DIR = chaine;
	std::cout << "Lecteur Dcamir trouvé";
	return true;
}

[kidpaddle2]

Es-tu sûr du code fourni ? Je croyais que boost::filesystem::exists() testait simplement l'existance d'un fichier ?

Ce que j'aimerais, c'est tester si le fichier correspond au type attendu... en utilisant path::name_checker, mais comment, telle est la question que je pose.

Merci de ta réponse.

[poukill]

La fonction exists permet de tester l'existence d'un fichier ou bien d'un dossier. Je l'ai déjà utilisé et ça fonctionne parfaitement bien !

D'après ce que j'ai compris, ça répondrait à ton problème. Mais si ce n'est pas le cas, précise ton problème un peu plus !

[kidpaddle2]

J'ai dû mal me faire comprendre :

Je code actuellement un lecteur audio. Dans celui-ci, on peut sélectionner dans une boîte de dialogue les musiques à écouter, seulement, c'est possible de sélectionner avec -par inadvertance ou non- d'autres fichiers, images par exemple, que je ne peux bien évidemment pas lire.

Le travail des name_checker (d'après ce que j'en ai compris) me permettrait -en fournissant une fonction de ce type retournant true si le fichier présente une extension compatible- de distinguer les fichiers valides ou non, mais je ne sais pas comment marche la distinction, ce que j'aimerais savoir ici.

[Matthieu Brucher]

Pour random -> http://miles.developpez.com/tutoriels/cpp/boost/random/
Pour file system, l'interface a un peu évolué, mais tu peux regarder ici : http://miles.developpez.com/tutoriel...st/filesystem/ pour commencer.
C'est très facile à faire en réalité : tu prends ton fichier, tu cherches son extension et tu regardes si elle vaut l'une de tes extensions à toi.

[kidpaddle2]

J'ai lu ces deux présentations (qui sont excellentes, bravo Miles ), mais :
-> Pour Boost.random, je cherche avant tout la simplicité : je ne sais que choisir parmi tous ces générateurs...
-> Pour Boost.FileSystem : j'y ai pensé (facile, avec boost::filesystem::extension()), mais je voulais savoir si déjà c'était possible, et si ce n'était pas plus approprié de dédier une fonction à la vérification* (le fameux name_checker) auquel cas je ne sais comment l'utiliser (ce qui fait alors l'objet de ce topic).

* : Par exemple :

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
bool IsMusicFile(std::string const &name)
{
    static std::list<std::string> validExtensions;
    if(validExtensions.empty())
    {
        validExtension.push_back(".mp3");
        //...
    }
 
    bool ret = false;
 
    for(std::list<std::string>::const_iterator it = validExtensions.begin() ; it != validExtensions.end() ; ++it)
    {
        if(boost::filesystem::extension(name) == *it)
        {
            ret = true;
            break;
        }
    }
    return ret;
}

[Matthieu Brucher]

Random : les Mersenne twister sont très bien, mais le pb de tout générateur est qu'il faudrea toujours que tu testes si le fichier n'existe pas à l'avance.

Filesystem : Tu ferais mieux de créer une classe qui gère ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
struct TypeChecker
{
FileChecker(const std::list<std::string>& extensions)
:extensions(extensions)
{
}
 
bool check(const std::string& filename) const
{
  std::string extension = boost::filesystem::extension(name);
  for (std::list<std::string>::cons_iterator it = extensions.begin(); it != extensions.end(); ++it)
  {
    if(extension == *it)
      return true;
  }
  return false;
}
private:
std::list<std::string> extensions;
};

Pour le name checker, je pense qu'il existait pas quand j'ai regardé ce module, donc je ne peux pas (pour l'instant) t'aider.

[kidpaddle2]

Merci, effectivement mieux vaut ça.

Par contre, s'il n'existait pas, pourquoi est-il dans ton exposé de la classe ? Et pourquoi ne trouve-je rien sur le sujet ?

[Matthieu Brucher]

Par contre, s'il n'existait pas, pourquoi est-il dans ton exposé de la classe ? Et pourquoi ne trouve-je rien sur le sujet ?

Je viens de comprendre... J'ai relu mon tuto

name_checker, c'est le type d'une fonction qui fera le check, mais c'est à toi de l'écrire. Un exemple typique est celle que j'ai écrite ici.

[kidpaddle2]

Oui, je sais, mais ce que je demande, c'est comment se manifeste le résultat de la fonction ?

Si le chemin n'est pas valide, est-ce que la variable de type path ayant requis l'appel d'une telle fonction est invalide, ou une méthode permet de déceler si elle correspond etc.

Je ne vois vraiment pas comment cela marche...

Edit: Illustration :

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
struct TypeChecker
{
    static void SetValidExtensions(std::list<std::string> const &ext)
    {
        extensions = ext;
    }
 
    static bool CheckName(std::string const &name)
    {
        bool ret = false;
        for(
                std::list<std::string>::const_iterator it = extensions.begin();
                it != extensions.end();
                ++it
            )
        {
            if(boost::filesystem::extension(name) == *it)
            {
                ret = true;
                break;
            }
        }
         return ret;
    }
 
    private:
       static std::list<std::string> extensions;
};
 
//...
 
boost::filesystem::path filePath(filesPaths[i], &TypeChecker::CheckName);
 
//How do we know the validity of filePath ?

[Matthieu Brucher]

Un name checker prend en argument un const std::string& et retourne un booléen, c'est tout.

[kidpaddle2]

Ca, à partir du proto du constructeur surchargé, je l'ai compris.

Ce que je veux dire, c'est que si on peut passer en paramètre un pointeur de fonction, c'est que la vérification se passe en interne, mais comment est-on informé du résultat ?

Je suis parfaitement stupide, ou juste un piètre locuteur ?

[Matthieu Brucher]

Le retour, c'est un booléen...

[kidpaddle2]

Mais je le sais, ça ^^

Je veux dire : je passe l'adresse de la fonction durant la contruction de la variable path. C'est donc la classe qui va se charger de la vérification dynamiquement, et non moi (ça m'arrange, c'est plus simple).

Vu que je ne l'appelle pas explicitement, je ne récupère pas son retour : je dois donc savoir d'une manière ou d'une autre si le chemin est valide, à travers la classe (ou une fonction fournie par boost::filesystem), mais comment, c'est ce que j'essaie de demander...

[Matthieu Brucher]

Dans Boost 1.34, je ne suis pas sûr que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

boost::filesystem::path filePath(filesPaths[i], &TypeChecker::CheckName);

soit possible d'après ce que je vois.
J'imagine qu'avec 1.33.1, il devait y avoir une exception levée (c'est facile, tu peux tester...).

[kidpaddle2]

Effectivement je n'avais pas pensé aux exceptions... pourquoi ne serait-ce plus valide dans Boost v1.34 ?

[Matthieu Brucher]

Parce que l'interface a changé.

[kidpaddle2]

Path name checking functionality has been moved out of class path and into separate free-functions. This still provides name checking for those who need it, but with much less impact on those who don't need it.

Je suppose que ça veut dire que cette fonctionnalité n'existe plus, et que je devrais faire comme ceci, pour tous mes chemins utilisés (c'est à ce moment qu'on se rend compte que l'ancienne fonctionnalité était plus simple pour moi) :

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
boost::filesystem::path filePath(filesPaths[i]);
if(TypeChecker::CheckPath(filePath))
    m_playlist.add(filePath.string()); //Example

[Matthieu Brucher]

Et si à la place tu utilises std::remove_if ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::erase(std::remove_if(liste.begin(), liste.end(), not_good_checker), liste.end()

où not_good_checker est ta fonction qui retourne true si le chemin n'est pas bon.