50 views

Kan ik een masker gebruiken om bestanden in een map met boost?

Hosted by Code Expert
c++

Ik wil over alle bestanden herhalen in een map die overeenkomt met iets als somefiles*.txt.

Doet boost::filesystemHeeft iets ingebouwd om dat te doen, of heb ik een regex nodig of iets tegen elke leaf()?

Antwoord 1, Autoriteit 100%

Bewerken : Zoals opgemerkt in de opmerkingen, is de onderstaande code geldig voor versies van boost::filesystemVóór V3. Raadpleeg de suggesties in de opmerkingen voor v3.

boost::filesystemHeeft geen jokertekenzoeking, u moet zelf bestanden filteren.

Dit is een codevoorbeeld die de inhoud van een map afhaalt met een boost::filesystem‘s directory_iteratoren filteren met boost::regex: 

const std::string target_path( "/my/directory/" );
const boost::regex my_filter( "somefiles.*\.txt" );
std::vector< std::string > all_matching_files;
boost::filesystem::directory_iterator end_itr; // Default ctor yields past-the-end
for( boost::filesystem::directory_iterator i( target_path ); i != end_itr; ++i )
{
    // Skip if not a file
    if( !boost::filesystem::is_regular_file( i->status() ) ) continue;
    boost::smatch what;
    // Skip if no match for V2:
    if( !boost::regex_match( i->leaf(), what, my_filter ) ) continue;
    // For V3:
    //if( !boost::regex_match( i->path().filename().string(), what, my_filter ) ) continue;
    // File matches, store it
    all_matching_files.push_back( i->leaf() );
}

(Als u op zoek bent naar een kant-en-klare les met de filtering van de Bouw-directory, bekijk QT’s QDir.)

Antwoord 2, Autoriteit 12%

Er is een Boost Range AdaptorsWay: 

#define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
#include <boost/filesystem.hpp>
#include <boost/range/adaptors.hpp>
namespace bfs = boost::filesystem;
namespace ba = boost::adaptors;
const std::string target_path( "/my/directory/" );
const boost::regex my_filter( "somefiles.*\.txt" );
boost::smatch what;
for (auto &entry: boost::make_iterator_range(bfs::directory_iterator(target_path), {})
| ba::filtered(static_cast<bool (*)(const bfs::path &)>(&bfs::is_regular_file))
| ba::filtered([&](const bfs::path &path){ return boost::regex_match(path.filename().string(), what, my_filter); })
)
{
  // There are only files matching defined pattern "somefiles*.txt".
  std::cout << entry.path().filename() << std::endl;
}

Antwoord 3, Autoriteit 5%

Mijn oplossing is in wezen hetzelfde als Julien-L, maar ingekapseld in het opnemen van het bestand is het mooier om te gebruiken. Geïmplementeerd met behulp van BOOST :: FileSystem V3. Ik denk dat er iets dergelijks niet is opgenomen in het Boost :: FileSystem direct omdat het afhankelijkheid van Boost :: Regex zou introduceren. 

#include "FilteredDirectoryIterator.h"
std::vector< std::string > all_matching_files;
std::for_each(
        FilteredDirectoryIterator("/my/directory","somefiles.*\.txt"),
        FilteredDirectoryIterator(),
        [&all_matching_files](const FilteredDirectoryIterator::value_type &dirEntry){
                all_matching_files.push_back(dirEntry.path());
            }
        );

Gebruik alternatief gefilterdRecursivirectoryiterator voor recursieve submappen zoeken: 

#include "FilteredDirectoryIterator.h"
std::vector< std::string > all_matching_files;
std::for_each(
        FilteredRecursiveDirectoryIterator("/my/directory","somefiles.*\.txt"),
        FilteredRecursiveDirectoryIterator(),
        [&all_matching_files](const FilteredRecursiveDirectoryIterator::value_type &dirEntry){
                all_matching_files.push_back(dirEntry.path());
            }
        );

FilteredDirectoryIterator.h

#ifndef TOOLS_BOOST_FILESYSTEM_FILTEREDDIRECTORYITERATOR_H_
#define TOOLS_BOOST_FILESYSTEM_FILTEREDDIRECTORYITERATOR_H_
#include "boost/filesystem.hpp"
#include "boost/regex.hpp"
#include <functional>
template <class NonFilteredIterator = boost::filesystem::directory_iterator>
class FilteredDirectoryIteratorTmpl
:   public std::iterator<
    std::input_iterator_tag, typename NonFilteredIterator::value_type
    >
{
private:
    typedef std::string string;
    typedef boost::filesystem::path path;
    typedef
        std::function<
            bool(const typename NonFilteredIterator::value_type &dirEntry)
            >
        FilterFunction;
    NonFilteredIterator it;
    NonFilteredIterator end;
    const FilterFunction filter;
public:
    FilteredDirectoryIteratorTmpl();
    FilteredDirectoryIteratorTmpl(
        const path &iteratedDir, const string &regexMask
        );
    FilteredDirectoryIteratorTmpl(
        const path &iteratedDir, const boost::regex &mask
        );
    FilteredDirectoryIteratorTmpl(
        const path &iteratedDir,
        const FilterFunction &filter
        );
    //preincrement
    FilteredDirectoryIteratorTmpl<NonFilteredIterator>& operator++() {
        for(++it;it!=end && !filter(*it);++it);
        return *this;
    };
    //postincrement
    FilteredDirectoryIteratorTmpl<NonFilteredIterator> operator++(int) {
        for(++it;it!=end && !filter(*it);++it);
        return FilteredDirectoryIteratorTmpl<NonFilteredIterator>(it,filter);
    };
    const boost::filesystem::directory_entry &operator*() {return *it;};
    bool operator!=(const FilteredDirectoryIteratorTmpl<NonFilteredIterator>& other)
    {
        return it!=other.it;
    };
    bool operator==(const FilteredDirectoryIteratorTmpl<NonFilteredIterator>& other)
    {
        return it==other.it;
    };
};
typedef
    FilteredDirectoryIteratorTmpl<boost::filesystem::directory_iterator>
    FilteredDirectoryIterator;
typedef
    FilteredDirectoryIteratorTmpl<boost::filesystem::recursive_directory_iterator>
    FilteredRecursiveDirectoryIterator;
template <class NonFilteredIterator>
FilteredDirectoryIteratorTmpl<NonFilteredIterator>::FilteredDirectoryIteratorTmpl()
:   it(),
    filter(
        [](const boost::filesystem::directory_entry& /*dirEntry*/){return true;}
        )
{
}
template <class NonFilteredIterator>
FilteredDirectoryIteratorTmpl<NonFilteredIterator>::FilteredDirectoryIteratorTmpl(
    const path &iteratedDir,const string &regexMask
    )
:   FilteredDirectoryIteratorTmpl(iteratedDir, boost::regex(regexMask))
{
}
template <class NonFilteredIterator>
FilteredDirectoryIteratorTmpl<NonFilteredIterator>::FilteredDirectoryIteratorTmpl(
    const path &iteratedDir,const boost::regex &regexMask
    )
:   it(NonFilteredIterator(iteratedDir)),
    filter(
        [regexMask](const boost::filesystem::directory_entry& dirEntry){
            using std::endl;
            // return false to skip dirEntry if no match
            const string filename = dirEntry.path().filename().native();
            return boost::regex_match(filename, regexMask);
        }
        )
{
    if (it!=end && !filter(*it)) ++(*this);
}
template <class NonFilteredIterator>
FilteredDirectoryIteratorTmpl<NonFilteredIterator>::FilteredDirectoryIteratorTmpl(
    const path &iteratedDir, const FilterFunction &filter
    )
:   it(NonFilteredIterator(iteratedDir)),
    filter(filter)
{
    if (it!=end && !filter(*it)) ++(*this);
}
#endif

Antwoord 4

Ik geloof dat de directory_iterators alleen alle bestanden in een directory zullen leveren. Het is aan jou om ze zo nodig te filteren.

Antwoord 5

Het geaccepteerde antwoord compileerde niet voor mij, zelfs niet toen ik i->path().extension()gebruikte in plaats van leaf(). Wat voor mij wel werkte, was een voorbeeld van deze website. Hier is de code, aangepast, om een ​​filter toe te passen:

vector<string> results;
filesystem::path filepath(fullpath_to_file);
filesystem::directory_iterator it(filepath);
filesystem::directory_iterator end;
const boost::regex filter("myfilter(capturing group)");
BOOST_FOREACH(filesystem::path const &p, make_pair(it, end))
{
     if(is_regular_File(p))
     {
          match_results<string::const_iterator> what;
          if (regex_search(it->path().filename().string(), what, pidFileFilter, match_default))
          {
               string res = what[1];
               results.push_back(res);
          }
     }
}

Ik gebruik Boost-versie: 1.53.0.

Waarom we niet allemaal gewoon glob()gebruiken en sommige regex is mij een raadsel.

Antwoord 6

Zoals vermeld aan het einde van Julien-L‘s post QDiris precies wat je wilt.
https://qt-project.org/doc/ qt-5.0/qtcore/qdir.html#QDir-3

Antwoord 7

Ik was eerder op zoek naar een oplossing hiervoor en ik denk dat mijn oplossing de eenvoudigste is

#include <boost/filesystem.hpp>
#include <boost/regex.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/exception/all.hpp>
struct dir_filter_iter
        : public boost::iterator_facade<
                dir_filter_iter,
                boost::filesystem::path,
                boost::forward_traversal_tag,
                boost::filesystem::path
        >
{
        using path = boost::filesystem::path;
        using impl_type = boost::filesystem::directory_iterator;
        dir_filter_iter():impl_(){}
        dir_filter_iter(path p, boost::regex rgx):impl_(std::move(p)),rgx_(std::move(rgx)){
                namespace bf = boost::filesystem;
                if( ! bf::is_directory(p) ){
                        BOOST_THROW_EXCEPTION(
                                boost::enable_error_info(std::domain_error("not a dir"))
                                << boost::errinfo_file_name(p.string()));
                }
             //advance to first matching item if impl_ is not already at end()
             if(impl_ != impl_type()) {
                  std::string s(impl_->path().string());
                  if( !boost::regex_match( s, rgx_ )) increment();
             }
        }
        private:
        friend class boost::iterator_core_access;
        bool equal(const dir_filter_iter& that)const{
                return this->impl_ == that.impl_;
        }
        void increment(){
                assert( impl_ != impl_type() );
                for(;;){
                        ++impl_;
                        if( impl_ == impl_type() )
                                break;
                        std::string s(impl_->path().string());
                        if( boost::regex_match( s, rgx_ ) ){
                                break;
                        }
                }
        }
        path dereference()const{
                assert( impl_ != impl_type() );
                return *impl_;
        }
        impl_type impl_;
        boost::regex rgx_;
};
struct dir_filter_iter_maker{
        using value_type = dir_filter_iter;
        explicit dir_filter_iter_maker(boost::regex rgx):rgx_(rgx){}
        value_type make()const{
                return value_type();
        }
        value_type make(boost::filesystem::path p)const{
                return value_type(std::move(p),rgx_);
        }
        template<typename... Args>
        auto operator()(Args&&... args)->decltype(make(args...)){
                return this->make(std::forward<Args>(args)...);
        }
        private:
        boost::regex rgx_;
};

Dan kunt u

doen

   dir_filter_iter_maker di_maker(boost::regex(R"_(.*\.hpp)_"));
    std::for_each( di_maker(p), di_maker(), [](const bf::path& p){std::cout << p.string() << "\n";});
Previous articleWanneer gebruik ik statische variabelen/functies in php?
Next articleWaarom heeft C++11 `make_shared` maar niet `make_unique`

Other episodes

Item uit vector verwijderen tijdens iteratie?

c++ Code Expert - 0
Ik heb een vector die items bevat die actief of inactief zijn. Ik wil dat de grootte van deze vector klein blijft vanwege prestatieproblemen,...
Read more

Is floating-point == ooit in orde?

c++ Code Expert - 0
Vandaag kwam ik software van derden tegen die we gebruiken en in hun voorbeeldcode stond iets in de trant van: // Defined in somewhere.h static const...
Read more

Waarom is de constructie van std::optioneel<int> duurder dan een std::pair<int, bool>?

c++ Code Expert - 0
Overweeg deze twee benaderingen die een "optionele int" kunnen vertegenwoordigen: using std_optional_int = std::optional<int>; using my_optional_int = std::pair<int, bool>; Gezien deze twee functies... auto get_std_optional_int() -> std_optional_int { ...
Read more

Visual Studio Code-opmaak voor “{ }”

c++ Code Expert - 0
Ik gebruik Ubuntu. C++ in Visual Studio Code pluist automatisch zoals if (condition == true) { DoStuff(); } In plaats daarvan wil ik doen: if (condition == true)...
Read more

Waarom krijg ik “onopgeloste externe symbolen”-fouten bij het gebruik van sjablonen?

c++ Code Expert - 0
Als ik C++-code voor een klasse schrijf met behulp van sjablonen en de code splits tussen een bronbestand (CPP) en een koptekstbestand (H), krijg...
Read more

Hoe std::map updaten na gebruik van de vindmethode?

c++ Code Expert - 0
Hoe de waarde van een sleutel in std::mapbij te werken na gebruik van de find-methode? Ik heb een kaart- en iteratordeclaratie als volgt: map <char, int>...
Read more

Wanneer kan het compileren van c++ zonder RTTI problemen veroorzaken?

c++ Code Expert - 0
Ik gebruik de vlag -fno-rttivan gcc om mijn C++ te compileren zonder informatie over het runtime-type. Ervan uitgaande dat ik dynamic_cast<>of typeid()niet gebruik, is er...
Read more

© Copyright - Code Expert 2021