path.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FILE_PATH_HPP__
#define NEFORCE_CORE_FILE_PATH_HPP__

 
#include "NeForce/core/container/vector.hpp"
#include "NeForce/core/interface/istringify.hpp"
NEFORCE_BEGIN_NAMESPACE__

 
class NEFORCE_API path_tree;
 

class NEFORCE_API path : public icommon<path>, public istringify<path> {
public:
    static constexpr size_t buffer_size = 8192;

    static constexpr string_view spliter =
#ifdef NEFORCE_PLATFORM_WINDOWS
            "\\/";
#elif defined(NEFORCE_PLATFORM_LINUX)
            "/";
#endif

    static constexpr char preferred_separator = spliter[0];
 

    class NEFORCE_API split_iterator {
    public:
        using value_type = string_view;                 
        using reference = value_type;                   
        using pointer = void;                           
        using iterator_category = forward_iterator_tag; 
        using difference_type = ptrdiff_t;              
 
    private:
        const string* path_ = nullptr; 
        size_t start_ = 0;             
        size_t end_ = 0;               
        bool done_ = true;             
        string current_part_;          

        void find_next();
 
    public:
        split_iterator() noexcept = default;

        explicit split_iterator(const string* path, const size_t pos = 0) :
        path_(path),
        start_(pos),
        done_(false) {
            if (path_ == nullptr || path_->empty() || start_ >= path_->size()) {
                done_ = true;
                return;
            }
            find_next();
        }

        reference operator*() const noexcept { return current_part_.view(); }

        split_iterator& operator++() {
            if (done_) {
                return *this;
            }
            start_ = end_ + 1;
            if (start_ >= path_->size()) {
                done_ = true;
                current_part_ = {};
            } else {
                find_next();
            }
            return *this;
        }

        split_iterator operator++(int) {
            split_iterator tmp = *this;
            ++*this;
            return tmp;
        }

        NEFORCE_NODISCARD bool operator==(const split_iterator& b) const noexcept {
            if (done_ && b.done_) {
                return true;
            }
            if (path_ != b.path_) {
                return false;
            }
            return start_ == b.start_;
        }

        NEFORCE_NODISCARD bool operator!=(const split_iterator& b) const noexcept { return !(*this == b); }
    };
 
private:
    string path_; 
 
public:
    path() = default;

    explicit path(string path) noexcept :
    path_(_NEFORCE move(path)) {}

    explicit path(const string_view path) :
    path_(path) {}

    explicit path(const char* path) :
    path_(path) {}
 
    path(const path&) = default;
    path(path&&) noexcept = default;
    path& operator=(const path&) = default;
    path& operator=(path&&) noexcept = default;

    NEFORCE_NODISCARD const string& str() const noexcept { return path_; }

    NEFORCE_NODISCARD string_view view() const noexcept { return path_.view(); }

    NEFORCE_NODISCARD const char* data() const noexcept { return path_.data(); }

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

    NEFORCE_NODISCARD split_iterator begin() const { return split_iterator(&path_, 0); }

    NEFORCE_NODISCARD split_iterator end() const { return {}; }

    NEFORCE_NODISCARD path parent_path() const;

    NEFORCE_NODISCARD string_view filename() const noexcept;

    NEFORCE_NODISCARD string_view stem() const noexcept;

    NEFORCE_NODISCARD string_view extension() const noexcept;

    NEFORCE_NODISCARD path lexically_normal() const;

    NEFORCE_NODISCARD path absolute(const path& base = current_path()) const;

    NEFORCE_NODISCARD path relative(const path& base) const;

    static path current_path();

    static path temp_directory_path();

    static path current_executable_path();

    path& operator/=(const path& other);

    path& operator/=(string_view other);

    path operator/(const path& other) const;

    path operator/(string_view pth) const;

    NEFORCE_NODISCARD path_tree to_tree() const;

    NEFORCE_NODISCARD vector<path> children(bool include_hidden = false) const;

    NEFORCE_NODISCARD vector<path> child_files(bool include_hidden = false) const;

    NEFORCE_NODISCARD vector<path> child_dirs(bool include_hidden = false) const;

    NEFORCE_NODISCARD bool exists() const noexcept;

    NEFORCE_NODISCARD bool is_directory() const noexcept;

    NEFORCE_NODISCARD bool is_file() const noexcept;

    NEFORCE_NODISCARD static bool exists(const string& path) noexcept;

    NEFORCE_NODISCARD static bool is_directory(const string& path) noexcept;

    NEFORCE_NODISCARD static bool is_file(const string& path) noexcept;

    NEFORCE_NODISCARD static string_view extension(string_view path) noexcept;

    explicit operator string_view() const noexcept { return path_.view(); }

    NEFORCE_NODISCARD bool equal_to(const path& rhs) const;

    NEFORCE_NODISCARD bool less_than(const path& rhs) const;

    NEFORCE_NODISCARD size_t to_hash() const;

    NEFORCE_NODISCARD string to_string() const { return lexically_normal().str(); }

    void swap(path& other) noexcept { path_.swap(other.path_); }
};
 
#ifdef NEFORCE_STANDARD_17
constexpr size_t path::buffer_size;
constexpr string_view path::spliter;
#endif
 // File
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FILE_PATH_HPP__