internal::GenericRegexSearch< RegexType, Allocator > Class Template Reference

#include <regex.h>

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

template<typename RegexType, typename Allocator = CrtAllocator>

typedef Encoding::Ch internal::GenericRegexSearch< RegexType, Allocator >::Ch

Definition at line 602 of file regex.h.

template<typename RegexType, typename Allocator = CrtAllocator>

typedef RegexType::EncodingType internal::GenericRegexSearch< RegexType, Allocator >::Encoding

Definition at line 601 of file regex.h.

template<typename RegexType, typename Allocator = CrtAllocator>

typedef RegexType::Range internal::GenericRegexSearch< RegexType, Allocator >::Range

private

Definition at line 643 of file regex.h.

template<typename RegexType, typename Allocator = CrtAllocator>

typedef RegexType::State internal::GenericRegexSearch< RegexType, Allocator >::State

private

Definition at line 642 of file regex.h.

Constructor & Destructor Documentation

template<typename RegexType, typename Allocator = CrtAllocator>

internal::GenericRegexSearch< RegexType, Allocator >::GenericRegexSearch ( const RegexType &  regex, Allocator *  allocator = 0  )

inline

Definition at line 604 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_);
    }

template<typename RegexType, typename Allocator = CrtAllocator>

internal::GenericRegexSearch< RegexType, Allocator >::~GenericRegexSearch ( )

inline

Definition at line 616 of file regex.h.

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

Member Function Documentation

template<typename RegexType, typename Allocator = CrtAllocator>

bool internal::GenericRegexSearch< RegexType, Allocator >::AddState ( Stack< Allocator > &  l, SizeType  index  )

inlineprivate

Definition at line 684 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.
    }

template<typename RegexType, typename Allocator = CrtAllocator>

size_t internal::GenericRegexSearch< RegexType, Allocator >::GetStateSetSize ( ) const

inlineprivate

Definition at line 679 of file regex.h.

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

template<typename RegexType, typename Allocator = CrtAllocator>

template<typename InputStream >

bool internal::GenericRegexSearch< RegexType, Allocator >::Match ( InputStream &  is )

inline

Definition at line 622 of file regex.h.

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

template<typename RegexType, typename Allocator = CrtAllocator>

bool internal::GenericRegexSearch< RegexType, Allocator >::Match ( const Ch *  s )

inline

Definition at line 626 of file regex.h.

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

template<typename RegexType, typename Allocator = CrtAllocator>

bool internal::GenericRegexSearch< RegexType, Allocator >::MatchRange ( SizeType  rangeIndex, unsigned  codepoint  ) const

inlineprivate

Definition at line 699 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;
    }

template<typename RegexType, typename Allocator = CrtAllocator>

template<typename InputStream >

bool internal::GenericRegexSearch< RegexType, Allocator >::Search ( InputStream &  is )

inline

Definition at line 632 of file regex.h.

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

template<typename RegexType, typename Allocator = CrtAllocator>

bool internal::GenericRegexSearch< RegexType, Allocator >::Search ( const Ch *  s )

inline

Definition at line 636 of file regex.h.

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

template<typename RegexType, typename Allocator = CrtAllocator>

template<typename InputStream >

bool internal::GenericRegexSearch< RegexType, Allocator >::SearchWithAnchoring ( InputStream &  is, bool  anchorBegin, bool  anchorEnd  )

inlineprivate

Definition at line 646 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;
    }

Member Data Documentation

template<typename RegexType, typename Allocator = CrtAllocator>

Allocator* internal::GenericRegexSearch< RegexType, Allocator >::allocator_

private

Definition at line 711 of file regex.h.

template<typename RegexType, typename Allocator = CrtAllocator>

Allocator* internal::GenericRegexSearch< RegexType, Allocator >::ownAllocator_

private

Definition at line 712 of file regex.h.

template<typename RegexType, typename Allocator = CrtAllocator>

const RegexType& internal::GenericRegexSearch< RegexType, Allocator >::regex_

private

Definition at line 710 of file regex.h.

template<typename RegexType, typename Allocator = CrtAllocator>

Stack<Allocator> internal::GenericRegexSearch< RegexType, Allocator >::state0_

private

Definition at line 713 of file regex.h.

template<typename RegexType, typename Allocator = CrtAllocator>

Stack<Allocator> internal::GenericRegexSearch< RegexType, Allocator >::state1_

private

Definition at line 714 of file regex.h.

template<typename RegexType, typename Allocator = CrtAllocator>

uint32_t* internal::GenericRegexSearch< RegexType, Allocator >::stateSet_

private

Definition at line 715 of file regex.h.

---

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

• art/rapidjson/internal/regex.h