123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260 |
- ///////////////////////////////////////////////////////////////////////////////
- /// \file regex_iterator.hpp
- /// Contains the definition of the regex_iterator type, an STL-compatible iterator
- /// for stepping through all the matches in a sequence.
- //
- // Copyright 2008 Eric Niebler. Distributed under the Boost
- // Software License, Version 1.0. (See accompanying file
- // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- #ifndef BOOST_XPRESSIVE_REGEX_ITERATOR_HPP_EAN_10_04_2005
- #define BOOST_XPRESSIVE_REGEX_ITERATOR_HPP_EAN_10_04_2005
- // MS compatible compilers support #pragma once
- #if defined(_MSC_VER)
- # pragma once
- #endif
- #include <boost/noncopyable.hpp>
- #include <boost/intrusive_ptr.hpp>
- #include <boost/iterator/iterator_traits.hpp>
- #include <boost/xpressive/detail/detail_fwd.hpp>
- #include <boost/xpressive/detail/core/access.hpp>
- #include <boost/xpressive/detail/utility/counted_base.hpp>
- namespace boost { namespace xpressive { namespace detail
- {
- //////////////////////////////////////////////////////////////////////////
- // regex_iterator_impl
- //
- template<typename BidiIter>
- struct regex_iterator_impl
- : counted_base<regex_iterator_impl<BidiIter> >
- {
- typedef detail::core_access<BidiIter> access;
- regex_iterator_impl
- (
- BidiIter begin
- , BidiIter cur
- , BidiIter end
- , BidiIter next_search
- , basic_regex<BidiIter> const &rex
- , regex_constants::match_flag_type flags
- , bool not_null = false
- )
- : rex_(rex)
- , what_()
- , state_(begin, end, what_, *access::get_regex_impl(rex_), flags)
- , flags_(flags)
- , not_null_(not_null)
- {
- this->state_.cur_ = cur;
- this->state_.next_search_ = next_search;
- }
- bool next()
- {
- this->state_.reset(this->what_, *access::get_regex_impl(this->rex_));
- if(!regex_search_impl(this->state_, this->rex_, this->not_null_))
- {
- return false;
- }
- // Report position() correctly by setting the base different from prefix().first
- access::set_base(this->what_, this->state_.begin_);
- this->state_.cur_ = this->state_.next_search_ = this->what_[0].second;
- this->not_null_ = (0 == this->what_.length());
- return true;
- }
- bool equal_to(regex_iterator_impl<BidiIter> const &that) const
- {
- return this->rex_.regex_id() == that.rex_.regex_id()
- && this->state_.begin_ == that.state_.begin_
- && this->state_.cur_ == that.state_.cur_
- && this->state_.end_ == that.state_.end_
- && this->flags_ == that.flags_
- ;
- }
- basic_regex<BidiIter> rex_;
- match_results<BidiIter> what_;
- match_state<BidiIter> state_;
- regex_constants::match_flag_type const flags_;
- bool not_null_;
- };
- } // namespace detail
- //////////////////////////////////////////////////////////////////////////
- // regex_iterator
- //
- template<typename BidiIter>
- struct regex_iterator
- {
- typedef basic_regex<BidiIter> regex_type;
- typedef match_results<BidiIter> value_type;
- typedef typename iterator_difference<BidiIter>::type difference_type;
- typedef value_type const *pointer;
- typedef value_type const &reference;
- typedef std::forward_iterator_tag iterator_category;
- /// INTERNAL ONLY
- typedef detail::regex_iterator_impl<BidiIter> impl_type_;
- regex_iterator()
- : impl_()
- {
- }
- regex_iterator
- (
- BidiIter begin
- , BidiIter end
- , basic_regex<BidiIter> const &rex
- , regex_constants::match_flag_type flags = regex_constants::match_default
- )
- : impl_()
- {
- if(0 != rex.regex_id()) // Empty regexes are guaranteed to match nothing
- {
- this->impl_ = new impl_type_(begin, begin, end, begin, rex, flags);
- this->next_();
- }
- }
- template<typename LetExpr>
- regex_iterator
- (
- BidiIter begin
- , BidiIter end
- , basic_regex<BidiIter> const &rex
- , detail::let_<LetExpr> const &args
- , regex_constants::match_flag_type flags = regex_constants::match_default
- )
- : impl_()
- {
- if(0 != rex.regex_id()) // Empty regexes are guaranteed to match nothing
- {
- this->impl_ = new impl_type_(begin, begin, end, begin, rex, flags);
- detail::bind_args(args, this->impl_->what_);
- this->next_();
- }
- }
- regex_iterator(regex_iterator<BidiIter> const &that)
- : impl_(that.impl_) // COW
- {
- }
- regex_iterator<BidiIter> &operator =(regex_iterator<BidiIter> const &that)
- {
- this->impl_ = that.impl_; // COW
- return *this;
- }
- friend bool operator ==(regex_iterator<BidiIter> const &left, regex_iterator<BidiIter> const &right)
- {
- if(!left.impl_ || !right.impl_)
- {
- return !left.impl_ && !right.impl_;
- }
- return left.impl_->equal_to(*right.impl_);
- }
- friend bool operator !=(regex_iterator<BidiIter> const &left, regex_iterator<BidiIter> const &right)
- {
- return !(left == right);
- }
- value_type const &operator *() const
- {
- return this->impl_->what_;
- }
- value_type const *operator ->() const
- {
- return &this->impl_->what_;
- }
- /// If what.prefix().first != what[0].second and if the element match_prev_avail is not set in
- /// flags then sets it. Then behaves as if by calling regex_search(what[0].second, end, what, *pre, flags),
- /// with the following variation: in the event that the previous match found was of zero length
- /// (what[0].length() == 0) then attempts to find a non-zero length match starting at what[0].second,
- /// only if that fails and provided what[0].second != suffix().second does it look for a (possibly
- /// zero length) match starting from what[0].second + 1. If no further match is found then sets
- /// *this equal to the end of sequence iterator.
- /// \post (*this)-\>size() == pre-\>mark_count() + 1
- /// \post (*this)-\>empty() == false
- /// \post (*this)-\>prefix().first == An iterator denoting the end point of the previous match found
- /// \post (*this)-\>prefix().last == (**this)[0].first
- /// \post (*this)-\>prefix().matched == (*this)-\>prefix().first != (*this)-\>prefix().second
- /// \post (*this)-\>suffix().first == (**this)[0].second
- /// \post (*this)-\>suffix().last == end
- /// \post (*this)-\>suffix().matched == (*this)-\>suffix().first != (*this)-\>suffix().second
- /// \post (**this)[0].first == The starting iterator for this match.
- /// \post (**this)[0].second == The ending iterator for this match.
- /// \post (**this)[0].matched == true if a full match was found, and false if it was a partial match (found as a result of the match_partial flag being set).
- /// \post (**this)[n].first == For all integers n \< (*this)-\>size(), the start of the sequence that matched sub-expression n. Alternatively, if sub-expression n did not participate in the match, then end.
- /// \post (**this)[n].second == For all integers n \< (*this)-\>size(), the end of the sequence that matched sub-expression n. Alternatively, if sub-expression n did not participate in the match, then end.
- /// \post (**this)[n].matched == For all integers n \< (*this)-\>size(), true if sub-expression n participated in the match, false otherwise.
- /// \post (*this)-\>position() == The distance from the start of the original sequence being iterated, to the start of this match.
- regex_iterator<BidiIter> &operator ++()
- {
- this->fork_(); // un-share the implementation
- this->next_();
- return *this;
- }
- regex_iterator<BidiIter> operator ++(int)
- {
- regex_iterator<BidiIter> tmp(*this);
- ++*this;
- return tmp;
- }
- private:
- /// INTERNAL ONLY
- void fork_()
- {
- if(1 != this->impl_->use_count())
- {
- // This is OK, the use_count is > 1
- impl_type_ *that = this->impl_.get();
- this->impl_ = new impl_type_
- (
- that->state_.begin_
- , that->state_.cur_
- , that->state_.end_
- , that->state_.next_search_
- , that->rex_
- , that->flags_
- , that->not_null_
- );
- detail::core_access<BidiIter>::get_action_args(this->impl_->what_)
- = detail::core_access<BidiIter>::get_action_args(that->what_);
- }
- }
- /// INTERNAL ONLY
- void next_()
- {
- BOOST_ASSERT(this->impl_ && 1 == this->impl_->use_count());
- if(!this->impl_->next())
- {
- this->impl_ = 0;
- }
- }
- intrusive_ptr<impl_type_> impl_;
- };
- }} // namespace boost::xpressive
- #endif
|