regex.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_STRING_REGEX_HPP__
#define NEFORCE_CORE_STRING_REGEX_HPP__

 
#include "NeForce/core/container/vector.hpp"
#include "NeForce/core/functional/function.hpp"
#include "NeForce/core/memory/unique_ptr.hpp"
#include "NeForce/core/string/string.hpp"
#include <pcre2.h>
NEFORCE_BEGIN_NAMESPACE__


struct regex_exception final : value_exception {
    explicit regex_exception(const char* info = "Regex Operation Failed") noexcept :
    value_exception(info) {}
 
    explicit regex_exception(const exception& e) :
    value_exception(e) {}
 
    ~regex_exception() override = default;
 
    NEFORCE_NODISCARD const char* type() const noexcept override { return "regex_exception"; }
};
 // Exceptions


class NEFORCE_API match_result {
public:
    using iterator = vector<string>::const_iterator; 
 
private:
    vector<string> groups_;                        
    vector<pair<size_t, size_t>> group_positions_; 
    size_t position_ = string::npos;               
    size_t length_ = 0;                            
    string subject_;                               
 
public:
    match_result() = default;

    match_result(string subject, size_t pos, size_t len, const vector<string>& groups,
                 vector<pair<size_t, size_t>> group_positions);

    NEFORCE_NODISCARD bool matched() const noexcept { return position_ != string::npos; }

    NEFORCE_NODISCARD size_t position() const noexcept { return position_; }

    NEFORCE_NODISCARD size_t length() const noexcept { return length_; }

    NEFORCE_NODISCARD string_view data() const noexcept { return matched() ? groups_[0].view() : ""; }

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

    NEFORCE_NODISCARD string_view operator[](const size_t idx) const noexcept {
        return idx < groups_.size() ? groups_[idx].view() : "";
    }

    NEFORCE_NODISCARD pair<size_t, size_t> position(const size_t idx) const noexcept {
        return idx < group_positions_.size() ? group_positions_[idx] : pair<size_t, size_t>{string::npos, 0};
    }

    NEFORCE_NODISCARD string_view prefix() const noexcept { return matched() ? subject_.view(0, position_) : ""; }

    NEFORCE_NODISCARD string_view suffix() const noexcept {
        return matched() ? subject_.view(position_ + length_) : "";
    }

    NEFORCE_NODISCARD string format(string_view fmt) const;

    NEFORCE_NODISCARD iterator begin() const noexcept { return groups_.begin(); }

    NEFORCE_NODISCARD iterator end() const noexcept { return groups_.end(); }
};
 
 
class NEFORCE_API regex_iterator;
 
class NEFORCE_API regex_token_iterator;

class NEFORCE_API regex {
private:
    struct pcre2_code_deleter {
        void operator()(::pcre2_code* code) const noexcept {
            if (code != nullptr) {
                ::pcre2_code_free(code);
            }
        }
    };
 
    unique_ptr<::pcre2_code, pcre2_code_deleter> code_; 
    string pattern_;                                    
    uint32_t options_;                                  
    int capture_count_ = 0;                             
 
    friend class regex_iterator;
    friend class regex_token_iterator;
 
private:
    void compile(const string& pattern, uint32_t options = 0);
 
    match_result do_match(::PCRE2_SPTR subject, size_t length, size_t start_offset, uint32_t options,
                          const string& subject_str) const;
 
public:
    explicit regex(const string& pattern, uint32_t options = 0);
 
    regex(regex&& other) noexcept;
    regex& operator=(regex&& other) noexcept;

    regex(const regex& other);

    regex& operator=(const regex& other);

    NEFORCE_NODISCARD match_result do_match(const string& str) const;

    NEFORCE_NODISCARD bool match(const string& str) const;

    NEFORCE_NODISCARD match_result search(const string& str, size_t pos = 0) const;

    NEFORCE_NODISCARD vector<match_result> find_all(const string& str) const;

    NEFORCE_NODISCARD string replace_first(const string& str, string_view fmt) const;

    NEFORCE_NODISCARD string replace_all(const string& str, string_view fmt) const;

    NEFORCE_NODISCARD string replace_all_callback(const string& str,
                                                  function<string(const match_result&)> callback) const;

    NEFORCE_NODISCARD vector<string> split(const string& str, int max_splits = -1) const;

    NEFORCE_NODISCARD int capture_count() const noexcept { return capture_count_; }

    NEFORCE_NODISCARD const string& pattern() const noexcept { return pattern_; }

    NEFORCE_NODISCARD bool valid() const noexcept { return code_ != nullptr; }

    NEFORCE_NODISCARD regex_iterator begin(const string& str) const;

    NEFORCE_NODISCARD regex_iterator end(const string& str) const;
};

class NEFORCE_API regex_iterator {
public:
    using iterator_category = forward_iterator_tag; 
    using value_type = match_result;                
    using difference_type = ptrdiff_t;              
    using pointer = const match_result*;            
    using reference = const match_result&;          
 
private:
    const regex* regex_ = nullptr; 
    string subject_;               
 
    match_result current_; 
    size_t next_pos_ = 0;  
    bool done_ = true;     
 
    void find_next();
 
public:
    regex_iterator() = default;

    regex_iterator(const regex* re, string str, size_t pos = 0);

    NEFORCE_NODISCARD reference operator*() const noexcept { return current_; }

    NEFORCE_NODISCARD pointer operator->() const noexcept { return &current_; }

    regex_iterator& operator++();

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

    NEFORCE_NODISCARD bool operator==(const regex_iterator& other) const noexcept;

    NEFORCE_NODISCARD bool operator!=(const regex_iterator& other) const noexcept { return !(*this == other); }

    static regex_iterator begin(const regex* re, const string& str) { return {re, str, 0}; }

    static regex_iterator end(const regex* re, const string& str) {
        regex_iterator it;
        it.regex_ = re;
        it.subject_ = str;
        it.done_ = true;
        return it;
    }
};

class NEFORCE_API regex_token_iterator {
public:
    enum class state {
        BEFORE_FIRST,    
        BETWEEN_MATCHES, 
        AFTER_LAST,      
        END              
    };
 
private:
    const regex* regex_ = nullptr;  
    string subject_;                
    regex_iterator match_iterator_; 
    regex_iterator end_iterator_;   
    string current_;                
    int index_ = 0;                 
    state state_ = state::END;      
    size_t last_pos_ = 0;           
 
private:
    void find_next();
 
public:
    regex_token_iterator() = default;

    regex_token_iterator(const regex* re, string str, int index = 0);

    NEFORCE_NODISCARD string_view operator*() const noexcept { return current_.view(); }

    regex_token_iterator& operator++();

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

    NEFORCE_NODISCARD bool operator==(const regex_token_iterator& other) const noexcept;

    NEFORCE_NODISCARD bool operator!=(const regex_token_iterator& other) const noexcept { return !(*this == other); }
};

inline regex_iterator regex::begin(const string& str) const { return regex_iterator::begin(this, str); }
 
inline regex_iterator regex::end(const string& str) const { return regex_iterator::end(this, str); }
 // Regex
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_STRING_REGEX_HPP__