Regex.h

#pragma once


#include <libutl/Array.h>
#include <libutl/BitArray.h>
#include <libutl/BoyerMooreSearch.h>
#include <libutl/Queue.h>
#include <libutl/Span.h>
#include <libutl/String.h>


UTL_NS_BEGIN;


class REnode;
class RegexMatch;



class Regex : public String
{
    UTL_CLASS_DECL(Regex, String);

public:
    Regex(const String& regex)
        : String(regex)
    {
        init();
        compile();
    }

    Regex(const char* str)
        : String(str)
    {
        init();
        compile();
    }

    virtual int compare(const Object& rhs) const;

    virtual void copy(const Object& rhs);

    virtual void steal(Object& rhs);

    void clear();

    bool compile();

    bool match(const String& str, RegexMatch* m = nullptr, size_t idx = 0) const;

    size_t searchReplace(String& str, const String& rep);

    bool
    ok() const
    {
        return getFlag(flg_ok);
    }

private:
    void init();
    void deInit();

    static String getToken(const TDequeIt<String>& it);

    bool
    isAnchored() const
    {
        return getFlag(flg_anchored);
    }

    static bool isSymbol(const TDequeIt<String>& it);

    bool match(RegexMatch& m, size_t& idx, const REnode* node) const;

    REnode* parseExpression(TDequeIt<String>& it, bool paren = false);
    REnode* parseBranch(TDequeIt<String>& it);
    REnode* parsePiece(TDequeIt<String>& it);
    REnode* parseAtom(TDequeIt<String>& it);
    void parseBracketExpr(TDequeIt<String>& it, BitArray& charSet, bool tv);

    void scan(Queue<String>& queue);

    void
    setAnchored(bool anchored)
    {
        setFlag(flg_anchored, anchored);
    }

    bool setCharSet(const REnode* node, BitArray& charSet);

    void
    setOK(bool ok)
    {
        setFlag(flg_ok, ok);
    }

    void setTail(REnode* chain, REnode* tail);

private:
    REnode* _start;
    TArray<REnode>* _regex;
    uint_t _parenNo;
    char _firstChar;
    BoyerMooreSearch<>* _mustStr;
    enum flg_t
    {
        flg_ok = 4,
        flg_anchored = 5
    };
};

// RegexMatch //////////////////////////////////////////////////////////////////////////////////////

/*
   Regular expression match information.

   RegexMatch stores information about matches that were found when comparing a String
   against a Regex.

   \author Adam McKee
   \ingroup string
*/


class RegexMatch : public utl::Object
{
    UTL_CLASS_DECL(RegexMatch, Object);
    UTL_CLASS_NO_COMPARE;
    UTL_CLASS_NO_COPY;

public:
    bool
    ok() const
    {
        return _matches != nullptr;
    }

    void
    clear()
    {
        _matchStr.clear();
        delete _matches;
        _matches = nullptr;
    }

    void
    set(const String& matchStr, const TArray<Span<size_t>>* matches)
    {
        delete _matches;
        _matchStr = matchStr;
        _matches = matches;
    }

    const String&
    matchString() const
    {
        return _matchStr;
    }

    size_t
    numMatchSpans() const
    {
        ASSERTD(ok());
        return _matches->size();
    }

    Span<size_t>&
    matchSpan(size_t idx)
    {
        ASSERTD(ok());
        return (*_matches)(idx);
    }

    const Span<size_t>&
    matchSpan(size_t idx) const
    {
        ASSERTD(ok());
        return (*_matches)(idx);
    }

    String replaceString(const String& str) const;

private:
    void
    init()
    {
        _matches = nullptr;
    }
    void
    deInit()
    {
        delete _matches;
    }

private:
    String _matchStr;
    const TArray<Span<size_t>>* _matches;
};


UTL_NS_END;