regex.h

Go to the documentation of this file.

 
#pragma once
 
#include <regex>
#include <promeki/core/namespace.h>
#include <promeki/core/string.h>
#include <promeki/core/stringlist.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class RegEx {
        public:
                using Flag = std::regex_constants::syntax_option_type;
 
                static constexpr Flag IgnoreCase = std::regex::icase;
 
                static constexpr Flag NoSubs = std::regex::nosubs;
 
                static constexpr Flag Optimize = std::regex::optimize;
 
                static constexpr Flag Collate = std::regex::collate;
 
                static constexpr Flag ECMAScript = std::regex::ECMAScript;
 
                static constexpr Flag Basic = std::regex::basic;
 
                static constexpr Flag Extended = std::regex::extended;
 
                static constexpr Flag Awk = std::regex::awk;
 
                static constexpr Flag Grep = std::regex::grep;
 
                static constexpr Flag EGrep = std::regex::egrep;
 
                static constexpr Flag DefaultFlags = ECMAScript | Optimize;
 
                RegEx(const String &pattern, Flag flags = DefaultFlags) : d(pattern.cstr(), flags), p(pattern) {}
 
                RegEx(const char *pattern, Flag flags = DefaultFlags) : d(pattern, flags), p(pattern) {}
 
                RegEx &operator=(const String &pattern) {
                        d = pattern.cstr();
                        p = pattern;
                        return *this;
                }
 
                String pattern() const {
                        return p;
                }
 
                bool match(const String &str) const {
                        std::smatch m;
                        return std::regex_match(str.str(), m, d);
                }
 
                bool search(const String &str) const {
                        return std::regex_search(str.str(), d);
                }
 
                StringList matches(const String& str) const {
                        StringList matches;
                        std::smatch match;
                        const std::string &s = str.str();
                        auto pos = s.cbegin();
                        while(std::regex_search(pos, s.cend(), match, d)) {
                                matches += match.str();
                                pos = match.suffix().first;
                        }
                        return matches;
                }
 
        private:
                std::regex      d;
                String          p;
};
 
PROMEKI_NAMESPACE_END