[A5] for_each_file - missing

no-reply@allegro.cc (PeKaGM) — Mon, 21 Jul 2014 23:54:39 +0000

Hi to all.I'm trying to rewrite Allegro 4 code to Allegro 5 and I miss function - for_each_file - in A5. I found some routines on the net but they are not working. I have only little free time for programing so I can't study those routines for errors.Could someone tell me where can I find functional routine or some really simple way to replace function for_each_file in A5. I need to find all files in directory for example ".jpg" files and store their file names in a field of strings.Thank you very much.

no-reply@allegro.cc (Edgar Reynaldo) — Tue, 22 Jul 2014 02:59:59 +0000

Basically you al_create_fs_entry a filesystem entry for your desired directory, then you al_open_directory the directory, al_read_directory it until there are no entries left, and then al_close_directory it.

Here is an example program that lists all the files in a given directory. You can specify the directory as a command line argument or else it will default to the current directory.

#SelectExpand
  1
  2#include "allegro5/allegro.h"
  3
  4#include 
  5#include 
  6
  7
  8int main(int argc , char** argv) {
 
 char* read_dir = 0;
 bool free_dir = false;
 bool close_dir = false;
 
 
 if (!al_init()) {return 1;}
 
 if (argc == 2) {
    // Use first argument as read directory
    read_dir = argv[1];
 }
 else {
    // Use current directory as read directory
    read_dir = al_get_current_directory();
    free_dir = true;
 }
 
 ALLEGRO_FS_ENTRY* fs_dir_entry = al_create_fs_entry(read_dir);
 
 
 unsigned int mode = al_get_fs_entry_mode(fs_dir_entry);
 
 if (!(mode & ALLEGRO_FILEMODE_ISDIR)) {
    printf("Invalid directory! (%s)\n" , read_dir);
 }
 
 if (!al_open_directory(fs_dir_entry)) {
    printf("Could not open directory %s\n" , read_dir);
 }
 else {
    /// Directory is now open
    close_dir = true;
    
    printf("Contents of directory %s\n" , read_dir);
    
    // prime the while loop
    ALLEGRO_FS_ENTRY* fs_entry = al_read_directory(fs_dir_entry);
 
    // Loop until there are not more entries
    while(fs_entry) {
       
       // String manip to get short name of file/dir
       std::string s = al_get_fs_entry_name(fs_entry);
       std::string s2;
       char path_sep = '\\';
       if (s.find_first_of('/') != std::string::npos) {
          path_sep = '/';
       }
       unsigned int last_separator = s.find_last_of(path_sep);
       if (last_separator == std::string::npos) {
          s2 = s;
       }
       else {
          s2 = s.substr(s.find_last_of(path_sep) + 1);
       }
    
       // output short file/dir name
       printf("%s\n" , s2.c_str());
       
       al_destroy_fs_entry(fs_entry);
       
       fs_entry = al_read_directory(fs_dir_entry);
    }
 }
 74
 
 if (close_dir) {
    al_close_directory(fs_dir_entry);
 }
 
 if (fs_dir_entry) {
    al_destroy_fs_entry(fs_dir_entry);
    fs_dir_entry = 0;
 }
 
 if (free_dir) {
    al_free(read_dir);
    read_dir = 0;
 }
 return 0;
 90}

no-reply@allegro.cc (beoran) — Tue, 22 Jul 2014 09:08:54 +0000

Hmm, seeing that the code to replicate for_each_file is relatively long, I'm in favor of adding an al_for_each_file() function.

no-reply@allegro.cc (Elias) — Tue, 22 Jul 2014 16:00:08 +0000

beoran +1

no-reply@allegro.cc (Thomas Fjellstrom) — Tue, 22 Jul 2014 19:10:37 +0000

He could also use the ALLEGRO_PATH api to handle paths and files. Would cut out a bit of that code.

no-reply@allegro.cc (Elias) — Tue, 22 Jul 2014 19:39:31 +0000

Thomas Fjellstrom said:

He could also use the ALLEGRO_PATH api to handle paths and files. Would cut out a bit of that code.

Replace the loop with this then:

#SelectExpand
  1while(fs_entry) {
  ALLEGRO_PATH *path = al_create_path(al_get_fs_entry_name(fs_entry))
  /* Note: ownership of the strings stays with path */
  char const *name = al_get_path_filename(path)
  if (not name[0]) {
      /* Note: ownership of the strings stays with path */
      name = al_get_path_component(path, -1);
  }
  if (strcmp(name, ".") != 0 && strcmp(name, "..") != 0) {
      bool is_dir = al_get_fs_entry_mode(fs_entry) & ALLEGRO_FILEMODE_ISDIR
 11
      printf("%s%s\n", name, is_dir ? "/" : "");
  }
  /* Note: This also invalidates the name string. */
  al_destroy_path(path) 
  al_destroy_fs_entry(fs_entry);
  fs_entry = al_read_directory(fs_dir_entry);
 18}

I also added directory detection, but it's still kinda longish. The proposed change would look something like:

void callback(char const *filename, void *user) {
    printf("%s\n", filename);
}
al_for_each_file(read_dir, callback, int flags, user);

Which is much more simple It also handles common errors someone would make on implementing it on their own, like not ignoring the "." and ".." entries we have on some platforms and dealing with directories where al_get_path_filename fails.

Possible flags could be:
FULL_PATH - pass the full path to the callback not just the filename
RECURSIVE - also recurse into any directories found
INCLUDE_DIRECTORIES - also call the callback with directory names not just files

no-reply@allegro.cc (beoran) — Tue, 22 Jul 2014 20:10:40 +0000

Actually I already made a patch, with two functions, documentation and a test. One function uses a callback with char * file names and the other with ALLEGRO_FS_ENTRY.

The flags parameter is a good idea though, I'll modify my patch to use that. I'll probably add the ALLEGRO_EACH_FILE_RECURSE, ALLEGRO_EACH_FILE_DIRECTORIES, ALLEGRO_EACH_FILE_DOTFILES and ALLEGRO_EACH_FILE_SHORT_PATH flags. The default call does not recurse, does not return directories, does return not dotfiles, and does return full file names, not partial ones, since full names are normally most useful.