Wsrtjtyk

I would like to use the ftw-function to recursivly traverse a filesystem structure. Additionally, the method shall be used inside of a class. Also, the entry-function, which is called by nftw(), belongs to the same class. That needs to be the case because the entry-function is supposed to change some class-members, dependent on the files that it finds.

When implementing such an approach, I get an error (see below). Is this an issue of syntax or is it not even possible to forward a pointer to a method to nftw()? In case it is not possible, do you know any alternative way to resursivly traverse a filesystem structure under linux?

class model

{

  public:

    boost::unordered_map<std::string, int> map;



    int configure(const char *name)

    {

        // ...

        ftw("DTModels/", this->ftw_entry, 15);

        // ...



        return = 0;

    }





  private:



    int ftw_entry(const char *filepath, const struct stat *info, const int typeflag)

    {

        // Here I want to change the member 'map'

        std::string filepath_s = filepath;

        std::cout << "FTW_Entry: " << filepath_s << std::endl;

    }

};





ERROR:

a pointer to a bound function may only be used to call the function

      ftw("DTModels/", this->ftw_entry, 15);

I haven't used ftw in many many years and since you ask for an alternative, take a look at std::filesystem (C++17). Many pre-C++17 installations have it available via boost or experimental. If you use one of the pre-C++17 implementations, you many need to remove some of the stat lines from the below to make it work.

#include <iostream>



//#define I_HAVE_BOOST



#if __cplusplus >= 201703L

  #include <filesystem>

  namespace fs = std::filesystem;

#elif I_HAVE_BOOST

  #include <boost/filesystem.hpp>

  namespace fs = boost::filesystem;

#else

  #include <experimental/filesystem>

  namespace fs = std::experimental::filesystem;

#endif



auto& out = std::cout;



void show_dent(const fs::directory_entry& dent) {

    static size_t indent=0;

    std::string ind(indent, ' ');



    fs::file_status lstat = dent.symlink_status();



    if( fs::is_symlink(lstat) ) {

        fs::path pp = fs::read_symlink(dent);

        out << ind << dent << " -> " << pp << "n";

        ++indent;

        show_dent(fs::directory_entry(pp));

        --indent;

    } else {

        if(fs::is_directory(dent)) {

            fs::directory_iterator dit_end;



            std::cout << "Directory " << dent << " includes the following files:n";

            ++indent;

            for(auto dit = fs::directory_iterator(dent); dit != dit_end; ++dit) {

                show_dent(*dit);

            }

            --indent;

        } else {

            fs::file_status stat = dent.status();



            out << ind << dent << "n"

                << ind << " statn"

                << ind << "  is_regular_file  : " << fs::is_regular_file(stat) << "n"

                << ind << "  is_directory     : " << fs::is_directory(stat) << "n"

                << ind << "  is_block_file    : " << fs::is_block_file(stat) << "n"

                << ind << "  is_character_file: " << fs::is_character_file(stat) << "n"

                << ind << "  is_fifo          : " << fs::is_fifo(stat) << "n"

                << ind << "  is_socket        : " << fs::is_socket(stat) << "n"

                << ind << "  is_symlink       : " << fs::is_symlink(stat) << "n"

                << ind << "  exists           : " << fs::exists(stat) << "n";

            if( fs::is_regular_file(stat) ) {

                out

                << ind << "  file_size        : " << fs::file_size(dent) << "n";

            }

        }

    }

}



int main(int argc, char* argv) {

    std::vector<std::string> args(argv+1, argv+argc);



    out << std::boolalpha;



    for(const auto& file_or_dir : args) {

        show_dent(fs::directory_entry(file_or_dir));

    }



    return 0;

}