[Boost.FileSystem::Path] Fonctionnement des name checkers

Version imprimable

26/07/2007, 19h56
kidpaddle2

[Boost.FileSystem::Path] Fonctionnement des name checkers

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.

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

Code:

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;
}

27/07/2007, 19h40
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.
29/07/2007, 20h39
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 ! :P
29/07/2007, 21h32
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.
31/07/2007, 13h46
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.

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:

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; }

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:

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.

31/07/2007, 20h04
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 :roll: ?
31/07/2007, 20h15
Matthieu Brucher

Citation:

Envoyé par kidpaddle2

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 :roll: ?

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.

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:

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 ?

31/07/2007, 23h09
Matthieu Brucher

Un name checker prend en argument un const std::string& et retourne un booléen, c'est tout.
01/08/2007, 11h07
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 ?
01/08/2007, 11h59
Matthieu Brucher

Le retour, c'est un booléen...
01/08/2007, 12h55
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...
01/08/2007, 13h21
Matthieu Brucher

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

Code:

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...).
01/08/2007, 13h26
kidpaddle2

Effectivement je n'avais pas pensé aux exceptions... pourquoi ne serait-ce plus valide dans Boost v1.34 ?
01/08/2007, 13h26
Matthieu Brucher

Parce que l'interface a changé.
01/08/2007, 15h04
kidpaddle2
Citation:

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:

1 2 3 boost::filesystem::path filePath(filesPaths[i]); if(TypeChecker::CheckPath(filePath)) m_playlist.add(filePath.string()); //Example
01/08/2007, 16h27
Matthieu Brucher

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

Code:

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.
01/08/2007, 23h02
kidpaddle2

C'est plus facile de faire un ajout conditionnel plutôt qu'un ajout, ainsi qu'une suppression conditionnelle...

Donc en gros, cette fonctionnalité a été supprimée (auquel cas ce topic deviendrait inutile) ?
02/08/2007, 11h43
Mat007

Salut,

Citation:

Path name checking functionality has been moved out of class path and into separate free-functions.

Moi là je comprends que ça a été déplacé de la classe 'path' vers des fonctions libres...
Donc ça doit toujours exister quelque part a priori.

MAT.
02/08/2007, 12h05
kidpaddle2

"Fonctions libres"... c'est vague, mais ce que moi, j'en ai compris, c'est que des fonctions externes à la classe s'occuperont de cette vérification (en d'autres mots, ça a été supprimé ^^), quitte à en fournir quelques-unes par défaut.

A la limite, je peux faire le concept du TypeChecker comme cela :
Code:

1 2 if(TypeChecker::CheckType<MusicType>(filePath)) m_playlist.add(filePath);
Je suppose que pour pareille fonction, je devrais utiliser une fonction template que je spécialise pour chacun des types, mais vu que le corps de la fonction reste le même, autant la généraliser pour chacun des types... comment devrais-je le faire ? Dériver chacun des types d'une structure bidon Type, n'accepter dans le template que des structures dérivées, mais comment faire pour le tableau statique de strings ?
Code:

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 { struct MusicType { static boost::array<std::string, 3> Ext; }; template <> static bool CheckType(std::string const &name) { } template <MusicType> static bool CheckType(std::string const &name) { bool ret = false; for( boost::array<std::string, 3>::const_iterator it = MusicType::Ext.begin() ; it != MusicType::Ext.end() ; ++it ) { if(boost::filesystem::extension(name) == *it) { ret = true; break; } } return ret; } }; boost::array<std::string, 3> TypeChecker::MusicType::Ext = make_array<std::string>(".mp3", ".ogg", ".wav"); //?
Là, c'est une question de conception et de manipulation des templates (bon, c'est pas du metaprogramming non plus), mais je ne vais tout de même pas créer un nouveau topic pour ça...

Merci d'avance.

P.S : Est ce que ça existe un moyen de simuler une enum de strings (pour du metaprogramming) ?