mirror of
https://github.com/ecency/ecency-mobile.git
synced 2024-12-24 13:53:23 +03:00
261 lines
8.9 KiB
C++
261 lines
8.9 KiB
C++
///////////////////////////////////////////////////////////////////////////////
|
|
/// \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
|