include/boost/regex/v5/regex_iterator.hpp

100.0% Lines (48/48) 62.8% List of functions (152/242)

[ ] prev/next file

regex_iterator.hpp

f(x) Functions (242)

Function Calls Lines Blocks

Line	Hits	Source Code
1		/*
2		*
3		* Copyright (c) 2003
4		* John Maddock
5		*
6		* Use, modification and distribution are subject to the
7		* Boost Software License, Version 1.0. (See accompanying file
8		* LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
9		*
10		*/
11
12		/*
13		* LOCATION: see http://www.boost.org for most recent version.
14		* FILE regex_iterator.hpp
15		* VERSION see <boost/version.hpp>
16		* DESCRIPTION: Provides regex_iterator implementation.
17		*/
18
19		#ifndef BOOST_REGEX_V5_REGEX_ITERATOR_HPP
20		#define BOOST_REGEX_V5_REGEX_ITERATOR_HPP
21
22		#include <boost/regex/v5/basic_regex.hpp>
23		#include <boost/regex/v5/match_results.hpp>
24		#ifndef BOOST_REGEX_AS_MODULE
25		#include <memory>
26		#endif
27
28		namespace boost{
29
30		template <class BidirectionalIterator,
31		class charT,
32		class traits>
33		class regex_iterator_implementation
34		{
35		typedef basic_regex<charT, traits> regex_type;
36
37		match_results<BidirectionalIterator> what; // current match
38		BidirectionalIterator base; // start of sequence
39		BidirectionalIterator end; // end of sequence
40		const regex_type re; // the expression
41		match_flag_type flags; // flags for matching
42
43		public:
44	110122x	regex_iterator_implementation(const regex_type* p, BidirectionalIterator last, match_flag_type f)
45	330366x	: base(), end(last), re(*p), flags(f){}
46	74881x	regex_iterator_implementation(const regex_iterator_implementation& other)
47	74881x	:what(other.what), base(other.base), end(other.end), re(other.re), flags(other.flags){}
48	110122x	bool init(BidirectionalIterator first)
49		{
50	110122x	base = first;
51	110122x	return regex_search(first, end, what, re, flags);
52		}
53	171600x	bool compare(const regex_iterator_implementation& that)
54		{
55	171600x	if(this == &that) return true;
56	21840x	return (&re.get_data() == &that.re.get_data()) && (end == that.end) && (flags == that.flags) && (what[0].first == that.what[0].first) && (what[0].second == that.what[0].second);
57		}
58	1297570x	const match_results<BidirectionalIterator>& get()
59	1297570x	{ return what; }
60	200932x	bool next()
61		{
62		//if(what.prefix().first != what[0].second)
63		// flags \|= match_prev_avail;
64	200932x	BidirectionalIterator next_start = what[0].second;
65	200932x	match_flag_type f(flags);
66	200932x	if(!what.length() \|\| (f & regex_constants::match_posix))
67	18708x	f \|= regex_constants::match_not_initial_null;
68		//if(base != next_start)
69		// f \|= regex_constants::match_not_bob;
70	200932x	bool result = regex_search(next_start, end, what, re, f, base);
71	200932x	if(result)
72	35275x	what.set_base(base);
73	200932x	return result;
74		}
75		private:
76		regex_iterator_implementation& operator=(const regex_iterator_implementation&);
77		};
78
79		BOOST_REGEX_MODULE_EXPORT template <class BidirectionalIterator,
80		class charT = typename std::iterator_traits<BidirectionalIterator>::value_type,
81		class traits = regex_traits<charT> >
82		class regex_iterator
83		{
84		private:
85		typedef regex_iterator_implementation<BidirectionalIterator, charT, traits> impl;
86		typedef std::shared_ptr<impl> pimpl;
87		public:
88		typedef basic_regex<charT, traits> regex_type;
89		typedef match_results<BidirectionalIterator> value_type;
90		typedef typename std::iterator_traits<BidirectionalIterator>::difference_type
91		difference_type;
92		typedef const value_type* pointer;
93		typedef const value_type& reference;
94		typedef std::forward_iterator_tag iterator_category;
95
96	110122x	regex_iterator(){}
97	110122x	regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
98		const regex_type& re,
99		match_flag_type m = match_default)
100	110122x	: pdata(new impl(&re, b, m))
101		{
102	110122x	if(!pdata->init(a))
103		{
104	18913x	pdata.reset();
105		}
106	110122x	}
107	93578x	regex_iterator(const regex_iterator& that)
108	93578x	: pdata(that.pdata) {}
109		regex_iterator& operator=(const regex_iterator& that)
110		{
111		pdata = that.pdata;
112		return *this;
113		}
114	413182x	bool operator==(const regex_iterator& that)const
115		{
116	413182x	if((pdata.get() == 0) \|\| (that.pdata.get() == 0))
117	241582x	return pdata.get() == that.pdata.get();
118	171600x	return pdata->compare(*(that.pdata.get()));
119		}
120	310838x	bool operator!=(const regex_iterator& that)const
121	310838x	{ return !(*this == that); }
122	389225x	const value_type& operator*()const
123	389225x	{ return pdata->get(); }
124	908345x	const value_type* operator->()const
125	908345x	{ return &(pdata->get()); }
126	200932x	regex_iterator& operator++()
127		{
128	200932x	cow();
129	200932x	if(0 == pdata->next())
130		{
131	165657x	pdata.reset();
132		}
133	200932x	return *this;
134		}
135		regex_iterator operator++(int)
136		{
137		regex_iterator result(*this);
138		++(*this);
139		return result;
140		}
141		private:
142
143		pimpl pdata;
144
145	200932x	void cow()
146		{
147		// copy-on-write
148	200932x	if(pdata.get() && (pdata.use_count() > 1))
149		{
150	74881x	pdata.reset(new impl(*(pdata.get())));
151		}
152	200932x	}
153		};
154
155		BOOST_REGEX_MODULE_EXPORT typedef regex_iterator<const char*> cregex_iterator;
156		BOOST_REGEX_MODULE_EXPORT typedef regex_iterator<std::string::const_iterator> sregex_iterator;
157		#ifndef BOOST_NO_WREGEX
158		BOOST_REGEX_MODULE_EXPORT typedef regex_iterator<const wchar_t*> wcregex_iterator;
159		BOOST_REGEX_MODULE_EXPORT typedef regex_iterator<std::wstring::const_iterator> wsregex_iterator;
160		#endif
161
162		// make_regex_iterator:
163		BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
164		inline regex_iterator<const charT, charT, traits> make_regex_iterator(const charT p, const basic_regex<charT, traits>& e, regex_constants::match_flag_type m = regex_constants::match_default)
165		{
166		return regex_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, m);
167		}
168		BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class ST, class SA>
169		inline regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, regex_constants::match_flag_type m = regex_constants::match_default)
170		{
171		return regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, m);
172		}
173
174		} // namespace boost
175
176		#endif // BOOST_REGEX_V5_REGEX_ITERATOR_HPP
177
178