class Q_CORE_EXPORT QRegularExpression
{
public:
    QRegularExpression();
    explicit QRegularExpression(const QString &pattern);
    QRegularExpression(const QRegularExpression &re);
    ~QRegularExpression();
    QRegularExpression &operator=(const QRegularExpression &re);

#ifdef Q_COMPILER_RVALUE_REFS
    inline QRegularExpression &operator=(QRegularExpression &&other)
    { d.swap(other.d); return *this; }
#endif

    inline void swap(QRegularExpression &other) { d.swap(other.d); }

    QString pattern() const;
    void setPattern(const QString &pattern);

    enum PatternOption {
        CaseInsensitiveOption          = 0x0001,
        InvertedGreedinessOption       = 0x0002,
        DotMatchesEverythingOption     = 0x0004,
        MultilineMatchOption           = 0x0008,
        ExtendedPatternSyntaxOption    = 0x0010,
        UseUnicodePropertiesOption     = 0x0020,
        AllowDuplicatedNamesOption     = 0x0040,
        DontCaptureOption              = 0x0080,
        MatchFirstlineOnlyOption       = 0x0100,
        DollarMatchesOnlyAtEndOption   = 0x0200
    };
    Q_DECLARE_FLAGS(PatternOptions, PatternOption)

    bool testPatternOption(PatternOption option) const;
    PatternOptions patternOptions() const;
    void setPatternOption(PatternOption option, bool on = true);
    void setPatternOptions(PatternOptions options, bool on = true);

    enum CompileHint {
        StudyPatternCompileHint = 0x0001,
        JitCompileHint          = 0x0002
    };
    Q_DECLARE_FLAGS(CompileHints, CompileHint)

    bool testCompileHint(CompileHint hint) const;
    CompileHints compileHints() const;
    void setCompileHint(CompileHint hint, bool on = true);
    void setCompileHints(CompileHints hints, bool on = true);

    enum MatchOption {
        AnchoredMatch        = 0x0001,
        NonEmptyMatch        = 0x0002,
        NonEmptyAtStartMatch = 0x0004
    };
    Q_DECLARE_FLAGS(MatchOptions, MatchOption)

    bool isValid() const;
    int patternErrorOffset() const;
    QString errorString() const;

    QRegularExpressionMatch match(const QString &subject, int offset = 0, MatchOptions options = 0) const;
    QRegularExpressionMatch partialMatch(const QString &subject,
                                         bool preferCompleteMatch,
                                         int offset = 0,
                                         MatchOptions options = 0) const;
    QRegularExpressionMatch exactMatch(const QString &subject) const;
    QRegularExpressionMatch lastMatch(const QString &subject) const;

    static QString escape(const QString &str);

    bool operator==(const QRegularExpression &re) const;
    bool operator!=(const QRegularExpression &re) const;
};

class Q_CORE_EXPORT QRegularExpressionMatch
{
public:
    QRegularExpressionMatch();
    ~QRegularExpressionMatch();
    QRegularExpressionMatch(const QRegularExpressionMatch &match);
    QRegularExpressionMatch &operator=(const QRegularExpressionMatch &match);

#ifdef Q_COMPILER_RVALUE_REFS
    inline QRegularExpressionMatch &operator=(QRegularExpressionMatch &&other)
    { d.swap(other.d); return *this; }
#endif
    inline void swap(QRegularExpressionMatch &other) { d.swap(other.d); }

    QRegularExpression regularExpression() const;
    QString subject() const;

    int capturedTextsCount() const;

    QString cap(int nth = 0) const;
    QStringRef capRef(int nth = 0) const;

    QString cap(const QString &name) const;
    QStringRef capRef(const QString &name) const;

    QStringList capturedTexts() const;
    QStringList capturedTextsForName(const QString &name) const;

    int pos(int nth = 0) const;
    int matchedLength(int nth = 0) const;
    int endPos(int nth = 0) const;

    int pos(const QString &name) const;
    int matchedLength(const QString &name) const;
    int endPos(const QString &name) const;

    bool hasMatch() const;
    bool hasPartialMatch() const;

    bool isValid() const;

    void nextMatch();
    QRegularExpressionMatch &operator++();
    QRegularExpressionMatch operator++(int);

    void previousMatch();
    QRegularExpressionMatch &operator--();
    QRegularExpressionMatch operator--(int);
};