include/boost/regex/v5/u32regex_token_iterator.hpp

38.1% Lines (43/113) 12.4% List of functions (12/97)

[ ] prev/next file n p prev/next uncovered line

u32regex_token_iterator.hpp

f(x) Functions (97)

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 u32regex_token_iterator.hpp
15		* VERSION see <boost/version.hpp>
16		* DESCRIPTION: Provides u32regex_token_iterator implementation.
17		*/
18
19		#ifndef BOOST_REGEX_V5_U32REGEX_TOKEN_ITERATOR_HPP
20		#define BOOST_REGEX_V5_U32REGEX_TOKEN_ITERATOR_HPP
21
22		#include <boost/regex/config.hpp>
23
24		#ifndef BOOST_REGEX_STANDALONE
25
26		#include <boost/config.hpp>
27		#if defined(BOOST_HAS_PRAGMA_ONCE)
28		#pragma once
29		#include <boost/regex/v5/icu.hpp>
30		#endif
31
32		#endif
33
34		namespace boost{
35
36		#ifdef BOOST_REGEX_MSVC
37		# pragma warning(push)
38		# pragma warning(disable:4700)
39		#endif
40
41		template <class BidirectionalIterator>
42		class u32regex_token_iterator_implementation
43		{
44		typedef u32regex regex_type;
45		typedef sub_match<BidirectionalIterator> value_type;
46
47		match_results<BidirectionalIterator> what; // current match
48		BidirectionalIterator end; // end of search area
49		BidirectionalIterator base; // start of search area
50		const regex_type re; // the expression
51		match_flag_type flags; // match flags
52		value_type result; // the current string result
53		int N; // the current sub-expression being enumerated
54		std::vector<int> subs; // the sub-expressions to enumerate
55
56		public:
57	1x	u32regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, int sub, match_flag_type f)
58	3x	: end(last), re(*p), flags(f){ subs.push_back(sub); }
59	✗	u32regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, const std::vector<int>& v, match_flag_type f)
60	✗	: end(last), re(*p), flags(f), subs(v){}
61		template <std::size_t CN>
62	✗	u32regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, const int (&submatches)[CN], match_flag_type f)
63	✗	: end(last), re(*p), flags(f)
64		{
65	✗	for(std::size_t i = 0; i < CN; ++i)
66		{
67	✗	subs.push_back(submatches[i]);
68		}
69	✗	}
70
71	1x	bool init(BidirectionalIterator first)
72		{
73	1x	base = first;
74	1x	N = 0;
75	1x	if(u32regex_search(first, end, what, re, flags, base) == true)
76		{
77	1x	N = 0;
78	1x	result = ((subs[N] == -1) ? what.prefix() : what[(int)subs[N]]);
79	1x	return true;
80		}
81	✗	else if((subs[N] == -1) && (first != end))
82		{
83	✗	result.first = first;
84	✗	result.second = end;
85	✗	result.matched = (first != end);
86	✗	N = -1;
87	✗	return true;
88		}
89	✗	return false;
90		}
91	✗	bool compare(const u32regex_token_iterator_implementation& that)
92		{
93	✗	if(this == &that) return true;
94	✗	return (&re.get_data() == &that.re.get_data())
95	✗	&& (end == that.end)
96	✗	&& (flags == that.flags)
97	✗	&& (N == that.N)
98	✗	&& (what[0].first == that.what[0].first)
99	✗	&& (what[0].second == that.what[0].second);
100		}
101	2x	const value_type& get()
102	2x	{ return result; }
103	2x	bool next()
104		{
105	2x	if(N == -1)
106	✗	return false;
107	2x	if(N+1 < (int)subs.size())
108		{
109	✗	++N;
110	✗	result =((subs[N] == -1) ? what.prefix() : what[subs[N]]);
111	✗	return true;
112		}
113		//if(what.prefix().first != what[0].second)
114		// flags \|= match_prev_avail \| regex_constants::match_not_bob;
115	2x	BidirectionalIterator last_end(what[0].second);
116	2x	if(u32regex_search(last_end, end, what, re, ((what[0].first == what[0].second) ? flags \| regex_constants::match_not_initial_null : flags), base))
117		{
118	1x	N =0;
119	1x	result =((subs[N] == -1) ? what.prefix() : what[subs[N]]);
120	1x	return true;
121		}
122	1x	else if((last_end != end) && (subs[0] == -1))
123		{
124	✗	N =-1;
125	✗	result.first = last_end;
126	✗	result.second = end;
127	✗	result.matched = (last_end != end);
128	✗	return true;
129		}
130	1x	return false;
131		}
132		private:
133		u32regex_token_iterator_implementation& operator=(const u32regex_token_iterator_implementation&);
134		};
135
136		template <class BidirectionalIterator>
137		class u32regex_token_iterator
138		{
139		private:
140		typedef u32regex_token_iterator_implementation<BidirectionalIterator> impl;
141		typedef std::shared_ptr<impl> pimpl;
142		public:
143		typedef u32regex regex_type;
144		typedef sub_match<BidirectionalIterator> value_type;
145		typedef typename std::iterator_traits<BidirectionalIterator>::difference_type
146		difference_type;
147		typedef const value_type* pointer;
148		typedef const value_type& reference;
149		typedef std::forward_iterator_tag iterator_category;
150
151	1x	u32regex_token_iterator(){}
152	1x	u32regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re,
153		int submatch = 0, match_flag_type m = match_default)
154	1x	: pdata(new impl(&re, b, submatch, m))
155		{
156	1x	if(!pdata->init(a))
157	✗	pdata.reset();
158	1x	}
159	✗	u32regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re,
160		const std::vector<int>& submatches, match_flag_type m = match_default)
161	✗	: pdata(new impl(&re, b, submatches, m))
162		{
163	✗	if(!pdata->init(a))
164	✗	pdata.reset();
165	✗	}
166		template <std::size_t N>
167	✗	u32regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re,
168		const int (&submatches)[N], match_flag_type m = match_default)
169	✗	: pdata(new impl(&re, b, submatches, m))
170		{
171	✗	if(!pdata->init(a))
172	✗	pdata.reset();
173	✗	}
174		u32regex_token_iterator(const u32regex_token_iterator& that)
175		: pdata(that.pdata) {}
176		u32regex_token_iterator& operator=(const u32regex_token_iterator& that)
177		{
178		pdata = that.pdata;
179		return *this;
180		}
181	3x	bool operator==(const u32regex_token_iterator& that)const
182		{
183	3x	if((pdata.get() == 0) \|\| (that.pdata.get() == 0))
184	3x	return pdata.get() == that.pdata.get();
185	✗	return pdata->compare(*(that.pdata.get()));
186		}
187	3x	bool operator!=(const u32regex_token_iterator& that)const
188	3x	{ return !(*this == that); }
189	2x	const value_type& operator*()const
190	2x	{ return pdata->get(); }
191	✗	const value_type* operator->()const
192	✗	{ return &(pdata->get()); }
193	2x	u32regex_token_iterator& operator++()
194		{
195	2x	cow();
196	2x	if(0 == pdata->next())
197		{
198	1x	pdata.reset();
199		}
200	2x	return *this;
201		}
202		u32regex_token_iterator operator++(int)
203		{
204		u32regex_token_iterator result(*this);
205		++(*this);
206		return result;
207		}
208		private:
209
210		pimpl pdata;
211
212	2x	void cow()
213		{
214		// copy-on-write
215	2x	if(pdata.get() && (pdata.use_count() > 1))
216		{
217	✗	pdata.reset(new impl(*(pdata.get())));
218		}
219	2x	}
220		};
221
222		typedef u32regex_token_iterator<const char*> utf8regex_token_iterator;
223		typedef u32regex_token_iterator<const UChar*> utf16regex_token_iterator;
224		typedef u32regex_token_iterator<const UChar32*> utf32regex_token_iterator;
225
226		// construction from an integral sub_match state_id:
227	✗	inline u32regex_token_iterator<const char> make_u32regex_token_iterator(const char p, const u32regex& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
228		{
229	✗	return u32regex_token_iterator<const char*>(p, p+std::strlen(p), e, submatch, m);
230		}
231		#ifndef BOOST_NO_WREGEX
232	✗	inline u32regex_token_iterator<const wchar_t> make_u32regex_token_iterator(const wchar_t p, const u32regex& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
233		{
234	✗	return u32regex_token_iterator<const wchar_t*>(p, p+std::wcslen(p), e, submatch, m);
235		}
236		#endif
237		#if !defined(BOOST_REGEX_UCHAR_IS_WCHAR_T)
238		inline u32regex_token_iterator<const UChar> make_u32regex_token_iterator(const UChar p, const u32regex& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
239		{
240		return u32regex_token_iterator<const UChar*>(p, p+u_strlen(p), e, submatch, m);
241		}
242		#endif
243		template <class charT, class Traits, class Alloc>
244	1x	inline u32regex_token_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator> make_u32regex_token_iterator(const std::basic_string<charT, Traits, Alloc>& p, const u32regex& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
245		{
246		typedef typename std::basic_string<charT, Traits, Alloc>::const_iterator iter_type;
247	1x	return u32regex_token_iterator<iter_type>(p.begin(), p.end(), e, submatch, m);
248		}
249	✗	inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const U_NAMESPACE_QUALIFIER UnicodeString& s, const u32regex& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
250		{
251	✗	return u32regex_token_iterator<const UChar*>(s.getBuffer(), s.getBuffer() + s.length(), e, submatch, m);
252		}
253
254		// construction from a reference to an array:
255		template <std::size_t N>
256	✗	inline u32regex_token_iterator<const char> make_u32regex_token_iterator(const char p, const u32regex& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
257		{
258	✗	return u32regex_token_iterator<const char*>(p, p+std::strlen(p), e, submatch, m);
259		}
260		#ifndef BOOST_NO_WREGEX
261		template <std::size_t N>
262	✗	inline u32regex_token_iterator<const wchar_t> make_u32regex_token_iterator(const wchar_t p, const u32regex& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
263		{
264	✗	return u32regex_token_iterator<const wchar_t*>(p, p+std::wcslen(p), e, submatch, m);
265		}
266		#endif
267		#if !defined(BOOST_REGEX_UCHAR_IS_WCHAR_T)
268		template <std::size_t N>
269		inline u32regex_token_iterator<const UChar> make_u32regex_token_iterator(const UChar p, const u32regex& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
270		{
271		return u32regex_token_iterator<const UChar*>(p, p+u_strlen(p), e, submatch, m);
272		}
273		#endif
274		template <class charT, class Traits, class Alloc, std::size_t N>
275	✗	inline u32regex_token_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator> make_u32regex_token_iterator(const std::basic_string<charT, Traits, Alloc>& p, const u32regex& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
276		{
277		typedef typename std::basic_string<charT, Traits, Alloc>::const_iterator iter_type;
278	✗	return u32regex_token_iterator<iter_type>(p.begin(), p.end(), e, submatch, m);
279		}
280		template <std::size_t N>
281	✗	inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const U_NAMESPACE_QUALIFIER UnicodeString& s, const u32regex& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
282		{
283	✗	return u32regex_token_iterator<const UChar*>(s.getBuffer(), s.getBuffer() + s.length(), e, submatch, m);
284		}
285
286		// construction from a vector of sub_match state_id's:
287	✗	inline u32regex_token_iterator<const char> make_u32regex_token_iterator(const char p, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
288		{
289	✗	return u32regex_token_iterator<const char*>(p, p+std::strlen(p), e, submatch, m);
290		}
291		#ifndef BOOST_NO_WREGEX
292	✗	inline u32regex_token_iterator<const wchar_t> make_u32regex_token_iterator(const wchar_t p, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
293		{
294	✗	return u32regex_token_iterator<const wchar_t*>(p, p+std::wcslen(p), e, submatch, m);
295		}
296		#endif
297		#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
298	✗	inline u32regex_token_iterator<const UChar> make_u32regex_token_iterator(const UChar p, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
299		{
300	✗	return u32regex_token_iterator<const UChar*>(p, p+u_strlen(p), e, submatch, m);
301		}
302		#endif
303		template <class charT, class Traits, class Alloc>
304	✗	inline u32regex_token_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator> make_u32regex_token_iterator(const std::basic_string<charT, Traits, Alloc>& p, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
305		{
306		typedef typename std::basic_string<charT, Traits, Alloc>::const_iterator iter_type;
307	✗	return u32regex_token_iterator<iter_type>(p.begin(), p.end(), e, submatch, m);
308		}
309	✗	inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const U_NAMESPACE_QUALIFIER UnicodeString& s, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
310		{
311	✗	return u32regex_token_iterator<const UChar*>(s.getBuffer(), s.getBuffer() + s.length(), e, submatch, m);
312		}
313
314		#ifdef BOOST_REGEX_MSVC
315		# pragma warning(pop)
316		#endif
317
318		} // namespace boost
319
320		#endif // BOOST_REGEX_V5_REGEX_TOKEN_ITERATOR_HPP
321
322
323
324
325