path_tree.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FILE_PATH_TREE_HPP__
#define NEFORCE_CORE_FILE_PATH_TREE_HPP__

 
#include "NeForce/core/file/path.hpp"
#include "NeForce/core/functional/function.hpp"
#include "NeForce/core/memory/weak_ptr.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API path_tree : public istringify<path_tree> {
public:
    enum class node_type : uint8_t {
        unknown = 0,   
        directory = 1, 
        file = 2,      
        symlink = 3,   
    };

    enum class visit_result : uint8_t {
        proceed = 0, 
        skip = 1,    
        stop = 2,    
    };

    class node : public enable_shared_from<node> {
        friend class path_tree;
 
    public:
        using ptr = shared_ptr<node>;             
        using weak_ptr = _NEFORCE weak_ptr<node>; 
        using children_list = vector<ptr>;        
 
    private:
        path path_;              
        node_type type_;         
        weak_ptr parent_;        
        children_list children_; 
        size_t depth_;           
 
    public:
        node() = default;

        explicit node(path p, node_type type, size_t depth = 0) :
        path_(_NEFORCE move(p)),
        type_(type),
        depth_(depth) {}
 
        node(const node&) = delete;
        node& operator=(const node&) = delete;
        node(node&&) noexcept = default;
        node& operator=(node&&) noexcept = default;

        NEFORCE_NODISCARD const path& get_path() const noexcept { return path_; }

        NEFORCE_NODISCARD node_type type() const noexcept { return type_; }

        NEFORCE_NODISCARD size_t depth() const noexcept { return depth_; }

        NEFORCE_NODISCARD bool is_directory() const noexcept { return type_ == node_type::directory; }

        NEFORCE_NODISCARD bool is_file() const noexcept {
            return type_ == node_type::file || type_ == node_type::symlink;
        }

        NEFORCE_NODISCARD bool is_root() const noexcept { return parent_.expired(); }

        NEFORCE_NODISCARD bool is_leaf() const noexcept { return children_.empty(); }

        NEFORCE_NODISCARD ptr parent() const noexcept { return parent_.lock(); }

        NEFORCE_NODISCARD const children_list& children() const noexcept { return children_; }

        NEFORCE_NODISCARD size_t child_count() const noexcept { return children_.size(); }

        NEFORCE_NODISCARD ptr find_child(string_view name) const noexcept;

        void add_child(ptr child);

        bool remove_child(string_view name) noexcept;
    };

    using visitor = function<visit_result(const node&)>;

    using filter = function<bool(const node&)>;

    struct scan_options {
        size_t max_depth = 0;

        bool include_hidden = false;

        bool follow_symlinks = false;

        bool files_only = false;

        bool dirs_only = false;

        vector<string> extensions;

        filter custom_filter;
    };
 
private:
    node::ptr root_; 
 
    static void scan_impl(const node::ptr& parent, const scan_options& options, size_t current_depth);
    static void traverse_dfs_impl(const node::ptr& current, const visitor& v, bool& stopped);
    static void collect_impl(const node::ptr& current, const filter& f, vector<node::ptr>& result);
    static node::ptr clone_node(const node::ptr& src, const node::ptr& new_parent, size_t depth);
 
    static node::ptr prune_impl(const node::ptr& src, const filter& f, const node::ptr& new_parent, size_t depth);
 
    string to_string_impl(const node::ptr& n, string_view indent, size_t depth) const;
 
public:
    path_tree() = default;

    explicit path_tree(path root_path) :
    root_(make_shared<node>(_NEFORCE move(root_path), node_type::directory, 0)) {}
 
    path_tree(const path_tree&) = default;
    path_tree(path_tree&&) noexcept = default;
    path_tree& operator=(const path_tree&) = default;
    path_tree& operator=(path_tree&&) noexcept = default;

    NEFORCE_NODISCARD static path_tree scan(const path& root, const scan_options& options);

    NEFORCE_NODISCARD node::ptr root() const noexcept { return root_; }

    NEFORCE_NODISCARD bool empty() const noexcept { return !root_; }

    NEFORCE_NODISCARD size_t size() const;

    NEFORCE_NODISCARD size_t max_depth() const;

    NEFORCE_NODISCARD node::ptr find(const path& p) const;

    NEFORCE_NODISCARD vector<node::ptr> find_all(string_view name) const;

    NEFORCE_NODISCARD vector<node::ptr> find_if(const filter& f) const;

    NEFORCE_NODISCARD vector<node::ptr> find_by_extension(string_view ext) const;

    void traverse_dfs(const visitor& visitor) const;

    void traverse_bfs(const visitor& visitor) const;

    void traverse_files(const visitor& visitor) const;

    void traverse_dirs(const visitor& visitor) const;

    node::ptr insert(const path& p, node_type type = node_type::file);

    bool remove(const path& p);

    void merge(const path_tree& other);

    NEFORCE_NODISCARD path_tree subtree(const path& p) const;

    NEFORCE_NODISCARD path_tree prune(const filter& f) const;

    NEFORCE_NODISCARD vector<path> all_paths() const;

    NEFORCE_NODISCARD vector<path> all_file_paths() const;

    NEFORCE_NODISCARD vector<path> all_dir_paths() const;

    NEFORCE_NODISCARD string to_string() const;

    NEFORCE_NODISCARD string to_string(string_view indent) const;
};
 // File
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FILE_PATH_TREE_HPP__