regex.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <regex>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/stringlist.h>
#include <promeki/result.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() : _valid(false) {}
 
                RegEx(const String &pattern, Flag flags = DefaultFlags) : p(pattern) {
                        try {
                                d.assign(pattern.cstr(), flags);
                                _valid = true;
                        } catch (const std::regex_error &) {
                                _valid = false;
                        }
                }
 
                RegEx(const char *pattern, Flag flags = DefaultFlags) : p(pattern) {
                        try {
                                d.assign(pattern, flags);
                                _valid = true;
                        } catch (const std::regex_error &) {
                                _valid = false;
                        }
                }
 
                static Result<RegEx> compile(const String &pattern, Flag flags = DefaultFlags) {
                        RegEx re;
                        try {
                                re.d.assign(pattern.cstr(), flags);
                                re._valid = true;
                                re.p = pattern;
                        } catch (const std::regex_error &) {
                                return makeError<RegEx>(Error::Invalid);
                        }
                        return makeResult(std::move(re));
                }
 
                RegEx &operator=(const String &pattern) {
                        p = pattern;
                        try {
                                d.assign(pattern.cstr());
                                _valid = true;
                        } catch (const std::regex_error &) {
                                _valid = false;
                        }
                        return *this;
                }
 
                bool isValid() const { return _valid; }
 
                String pattern() const { return p; }
 
                bool match(const String &str) const {
                        if (!_valid) return false;
                        std::smatch m;
                        return std::regex_match(str.str(), m, d);
                }
 
                bool search(const String &str) const {
                        if (!_valid) return false;
                        return std::regex_search(str.str(), d);
                }
 
                StringList matches(const String &str) const {
                        StringList matches;
                        if (!_valid) return 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;
                bool       _valid = false;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE