Discussion :

[Etudiant_bts]

Bonjour !

J'ai pu découvrir boost/filesystem, une librairie qui a un grand potentiel sûrement inexploité en grande partie à cause de .... sa pauvre documentation.
Qu'importe, je me bats, google est mon ami, j'essaye plein de choses pour arriver à mes fins, je vais par tâtonnement quand il n'y a pas d'autres choix
Je souhaite réaliser un programme portable, je suis actuellement en train de développer une fonction qui explore récursivement un chemin donné et deux problèmes se posent :

-J'ai cherché sans succès si il y a un moyen avec boost/filesystem de savoir si un répertoire donné est caché (répertoire commençant par "." sous linux et je ne sais pas quelle est la différenciation ni sous windows et mac, mais je sais que cela existe au moins sous windows). Explorer les dossiers cachés est une perte de temps et une source d'erreurs pour mon programme, je souhaiterais donc qu'ils soient reconnus et ignorés.

-En faisant divers essais dans le but de trouver un moyen de différencier les dossiers cachés, j'ai rencontré un autre problème. J'ai pensé à utiliser les fonctions de vérifications de portabilité des noms utilisés pour reconnaître les dossiers cachés (portable_name et portable_posix_name). En explorant mon système avec ces fonctions, je me suis aperçu qu'il me considérait des noms de dossiers parfois très simples comme n'étant pas portables. En voici quelques exemples :

Mika - Life In Cartoon Motion
Benny Benassi
Green Day
American Idiot

Ces dossiers ne contiennent pourtant aucun caractère pouvant gêner leur portabilité sur différents systèmes. Je n'ai pas trouvé de point commun entre ces différents dossier, certains avaient été créés sous windows et d'autres ont étés créés sous Linux (mon système actuellement). Je ne comprends pas pour quelle raison ces dossiers sont considérés par Boost comme ayant un nom non portable

je vous donne le code de ma fonction, si jamais cela peut vous parler un peu plus :

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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
/**
 * This method lists recursively all files present in the path contained in the attribute pathOfDirectory
 * [input parameters]
 * none
 * [output parameter]
 * none
 */
void Directory::exploreDirectoryRecursively()
{
	/**
         * if the path given is effectively a directory
         */
	if (bfs::is_directory(this->pathOfDirectory))
  	{	
  		/**
                 * a recursive directory iterators is created :
                 * end_rdit which is the end of the iterating process
                 */
  		bfs::recursive_directory_iterator end_rdit;
	  	/**
                 * the recursive directory iterator rdit is created
                 * rdit is iterated until it reaches the end of the directory
                 */	
	    for (bfs::recursive_directory_iterator rdit(this->pathOfDirectory); rdit != end_rdit; ++rdit)
	    { 
             /**
               * if the iterator contains a path finishing with a directory
               */ 
	      if(bfs::is_directory(rdit->path()))
	      	{
                       /**
                        * if the directory name is not portable through multiple OS
                        * it is displayed
                        */
	      		cout << rdit->path().stem() << " n est pas un dossier portable" << endl;
	      	}
	      }
	      /**
               * if the path is a symbolic link
               * iteration may loop endlessly by following it
               * so we ask to the iterator to not follow it
               */
	      if(bfs::is_symlink(rdit->path()))
	      {
	      	rdit.no_push();
	      }
	    }
  	}
  	else
  	{
  		cout << (bfs::exists(this->pathOfDirectory)? "Found: " : "Not found: ") << this->pathOfDirectory << '\n';
  	}
 
	return;
}

Voilà, peut-être pourrez-vous m'aider sur ces 2 points.

Merci d'avance

[Alp]

Tu t'es renseigné sur la "politique" de Boost.Filesystem vis à vis des espaces dans les noms de dossiers ?

Le problème n'est probablement pas présent sur des dossiers dont les noms ne comportent pas d'espace.

[Etudiant_bts]

Toute la doc disponible sur la portabilité des noms de fichiers et de dossiers ne mentionne pas les espaces, même les articles sur la norme posix dont les liens sont donnés dans la doc n'en font pas mention. Et puis, il faut le dire, les espaces dans les noms de dossiers et fichiers sont supportés par tous les systèmes Unix et win32 à l'heure actuelle, je ne vois donc pas pourquoi ce ne serait pas portable
Quant à la détection des dossiers et fichiers cachés par une fonction portable, ça n'existe apparemment pas sous boost, c'est peut-être quelque chose auquel ils n'ont pas pensé.
Donc je vais devoir créer des bouts de codes spéciaux suivants que le code est exécuté sous unix ou windows.

A moins qu'il existe une meilleure solution ?

[koala01]

Salut,

Et puis, il faut le dire, les espaces dans les noms de dossiers et fichiers sont supportés par tous les systèmes Unix et win32 à l'heure actuelle, je ne vois donc pas pourquoi ce ne serait pas portable

Toute la nuance est là: à l'heure actuelle...

Les premières versions de windows utilisaient les noms DOS (8 caractères + 3 d'extension, sans espace), mais les temps ont changé

Sous *nux, un espace doit être échappé ( "mon dossier" doit apparaitre sous la forme de "mon\ dossier").

Alors, effectivement, linux admet à l'heure actuelle de reconnaitre des noms contenant des espaces, mais je crois que c'est déjà une digression par rapport à la norme POSIX (à vérifier)

Tu remarquera d'ailleurs bien souvent que les fichiers et dossiers ne contiennent à la base pas d'espace sous linux

[Etudiant_bts]

Comme je l'ai écrit plus haut, j'ai déjà vérifié les documents de la norme POSIX pointés par la doc de Boost concernant le nom des fichiers/dossiers et leur portabilité. Il n'est pas question d'espaces dans cette doc.

La portabilité des noms de fichiers ou dossiers n'est foncièrement pas très importante pour mon programme, il faudra juste que les dossiers qu'il créés possèdent des noms supportés par le système où il est exécuté. Ce qui doit être portable, c'est tout le code qu'il y a dérrière

Par contre, comment différencier un dossier windows caché, par le code ? Sous linux le nom commence par un point, quelle est la spécificité sous windows ? Je n'ai pas pu trouver des explications claires sur le sujet, quelqu'un saurait-il comment faire ?

Merci

[Etudiant_bts]

J'ai trouvé un bout de code spécifique windows pour détecter les fichiers cachés sous windows. Pour ce qui est de la portabilité des noms de fichiers, pour ce que je souhaite faire, j'ai réalisé que des noms portables suivants les différents OS ne m'est pas utile, il suffit juste que les noms soient compatibles avec l'OS sur lequel l'application est excécutée.

Merci de votre aide.