GenericRegexSearch< RegexType, Allocator >

#include <regex.h>

Collaboration diagram for GenericRegexSearch< RegexType, Allocator >:

Public Types
typedef RegexType::EncodingType	Encoding
typedef Encoding::Ch	Ch

Public Member Functions
	GenericRegexSearch (const RegexType &regex, Allocator *allocator=0)
	~GenericRegexSearch ()
template<typename InputStream >
bool	Match (InputStream &is)
bool	Match (const Ch *s)
template<typename InputStream >
bool	Search (InputStream &is)
bool	Search (const Ch *s)

Private Types
typedef RegexType::State	State
typedef RegexType::Range	Range

Private Member Functions
template<typename InputStream >
bool	SearchWithAnchoring (InputStream &is, bool anchorBegin, bool anchorEnd)
size_t	GetStateSetSize () const
bool	AddState (Stack< Allocator > &l, SizeType index)
bool	MatchRange (SizeType rangeIndex, unsigned codepoint) const

Private Attributes
const RegexType &	regex_
Allocator *	allocator_
Allocator *	ownAllocator_
Stack< Allocator >	state0_
Stack< Allocator >	state1_
uint32_t *	stateSet_

Detailed Description

template<typename RegexType, typename Allocator = CrtAllocator>
class internal::GenericRegexSearch< RegexType, Allocator >

Definition at line 79 of file regex.h.

Member Typedef Documentation

Ch

typedef Encoding::Ch Ch

Definition at line 610 of file regex.h.

Encoding

typedef RegexType::EncodingType Encoding

Definition at line 609 of file regex.h.

Range

typedef RegexType::Range Range

private

Definition at line 651 of file regex.h.

State

typedef RegexType::State State

private

Definition at line 650 of file regex.h.

Constructor & Destructor Documentation

GenericRegexSearch()

GenericRegexSearch ( const RegexType &  regex, Allocator *  allocator = 0  )

inline

Definition at line 612 of file regex.h.

                                                                         : 
        regex_(regex), allocator_(allocator), ownAllocator_(0),
        state0_(allocator, 0), state1_(allocator, 0), stateSet_()
    {
        RAPIDJSON_ASSERT(regex_.IsValid());
        if (!allocator_)
            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
        stateSet_ = static_cast<unsigned*>(allocator_->Malloc(GetStateSetSize()));
        state0_.template Reserve<SizeType>(regex_.stateCount_);
        state1_.template Reserve<SizeType>(regex_.stateCount_);
    }

~GenericRegexSearch()

~GenericRegexSearch ( )

inline

Definition at line 624 of file regex.h.

                          {
        Allocator::Free(stateSet_);
        RAPIDJSON_DELETE(ownAllocator_);
    }

Member Function Documentation

AddState()

bool AddState ( Stack< Allocator > &  l, SizeType  index  )

inlineprivate

Definition at line 692 of file regex.h.

                                                       {
        RAPIDJSON_ASSERT(index != kRegexInvalidState);

        const State& s = regex_.GetState(index);
        if (s.out1 != kRegexInvalidState) { // Split
            bool matched = AddState(l, s.out);
            return AddState(l, s.out1) || matched;
        }
        else if (!(stateSet_[index >> 5] & (1u << (index & 31)))) {
            stateSet_[index >> 5] |= (1u << (index & 31));
            *l.template PushUnsafe<SizeType>() = index;
        }
        return s.out == kRegexInvalidState; // by using PushUnsafe() above, we can ensure s is not validated due to reallocation.
    }

GetStateSetSize()

size_t GetStateSetSize ( ) const

inlineprivate

Definition at line 687 of file regex.h.

                                   {
        return (regex_.stateCount_ + 31) / 32 * 4;
    }

Match() [1/2]

bool Match ( InputStream &  is )

inline

Definition at line 630 of file regex.h.

                                {
        return SearchWithAnchoring(is, true, true);
    }

Match() [2/2]

bool Match ( const Ch *  s )

inline

Definition at line 634 of file regex.h.

                            {
        GenericStringStream<Encoding> is(s);
        return Match(is);
    }

MatchRange()

bool MatchRange ( SizeType  rangeIndex, unsigned  codepoint  ) const

inlineprivate

Definition at line 707 of file regex.h.

                                                                   {
        bool yes = (regex_.GetRange(rangeIndex).start & RegexType::kRangeNegationFlag) == 0;
        while (rangeIndex != kRegexInvalidRange) {
            const Range& r = regex_.GetRange(rangeIndex);
            if (codepoint >= (r.start & ~RegexType::kRangeNegationFlag) && codepoint <= r.end)
                return yes;
            rangeIndex = r.next;
        }
        return !yes;
    }

Search() [1/2]

bool Search ( InputStream &  is )

inline

Definition at line 640 of file regex.h.

                                 {
        return SearchWithAnchoring(is, regex_.anchorBegin_, regex_.anchorEnd_);
    }

Here is the caller graph for this function:

Search() [2/2]

bool Search ( const Ch *  s )

inline

Definition at line 644 of file regex.h.

                             {
        GenericStringStream<Encoding> is(s);
        return Search(is);
    }

SearchWithAnchoring()

bool SearchWithAnchoring ( InputStream &  is, bool  anchorBegin, bool  anchorEnd  )

inlineprivate

Definition at line 654 of file regex.h.

                                                                                {
        DecodedStream<InputStream, Encoding> ds(is);

        state0_.Clear();
        Stack<Allocator> *current = &state0_, *next = &state1_;
        const size_t stateSetSize = GetStateSetSize();
        std::memset(stateSet_, 0, stateSetSize);

        bool matched = AddState(*current, regex_.root_);
        unsigned codepoint;
        while (!current->Empty() && (codepoint = ds.Take()) != 0) {
            std::memset(stateSet_, 0, stateSetSize);
            next->Clear();
            matched = false;
            for (const SizeType* s = current->template Bottom<SizeType>(); s != current->template End<SizeType>(); ++s) {
                const State& sr = regex_.GetState(*s);
                if (sr.codepoint == codepoint ||
                    sr.codepoint == RegexType::kAnyCharacterClass || 
                    (sr.codepoint == RegexType::kRangeCharacterClass && MatchRange(sr.rangeStart, codepoint)))
                {
                    matched = AddState(*next, sr.out) || matched;
                    if (!anchorEnd && matched)
                        return true;
                }
                if (!anchorBegin)
                    AddState(*next, regex_.root_);
            }
            internal::Swap(current, next);
        }

        return matched;
    }

Here is the call graph for this function:

Member Data Documentation

allocator_

Allocator* allocator_

private

Definition at line 719 of file regex.h.

ownAllocator_

Allocator* ownAllocator_

private

Definition at line 720 of file regex.h.

regex_

const RegexType& regex_

private

Definition at line 718 of file regex.h.

state0_

Stack<Allocator> state0_

private

Definition at line 721 of file regex.h.

state1_

Stack<Allocator> state1_

private

Definition at line 722 of file regex.h.

stateSet_

uint32_t* stateSet_

private

Definition at line 723 of file regex.h.

---

The documentation for this class was generated from the following file:

• rapidjson/internal/regex.h