pattern_filter.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>
#include <functional>
#include "filesystem.h"
 
namespace fs
{
 
class wildcard_pattern
{
public:
    explicit wildcard_pattern(const std::string& pattern);
 
    auto matches(const std::string& str) const -> bool;
 
    auto get_pattern() const -> const std::string& { return pattern_; }
 
private:
    std::string pattern_;
    
    auto match_impl(const char* pattern, const char* str) const -> bool;
};
 
class pattern_filter
{
public:
    pattern_filter() = default;
 
    explicit pattern_filter(const std::string& include_pattern);
 
    pattern_filter(const std::vector<std::string>& include_patterns,
                   const std::vector<std::string>& exclude_patterns = {});
 
    void add_include_pattern(const std::string& pattern);
 
    void add_exclude_pattern(const std::string& pattern);
 
    auto should_include(const fs::path& path) const -> bool;
 
    auto should_include_filename(const std::string& filename) const -> bool;
 
    auto has_patterns() const -> bool;
 
    auto is_wildcard() const -> bool;
 
    auto get_include_patterns() const -> const std::vector<wildcard_pattern>&;
 
    auto get_exclude_patterns() const -> const std::vector<wildcard_pattern>&;
 
private:
    std::vector<wildcard_pattern> include_patterns_;
    std::vector<wildcard_pattern> exclude_patterns_;
};
 
auto make_pattern_filter(const std::string& pattern) -> pattern_filter;
 
auto make_pattern_filter(const std::vector<std::string>& includes,
                         const std::vector<std::string>& excludes = {}) -> pattern_filter;
 
} // namespace fs